Joined Flow

options {
    IGNORE_CASE=true;
    VISITOR=true;
    NODE_DEFAULT_VOID = true;
    NODE_PREFIX = "";
    MULTI = true;
    LOOKAHEAD = 4;
}

PARSER_BEGIN(CriteriaParser)

package com.emasphere.operation.injection.dsl.flow.join;

import java.io.StringReader;
import java.io.Reader;
import java.util.List;
import java.util.ArrayList;
import java.math.BigDecimal;
import com.emasphere.operation.injection.model.flow.definition.DataType;

public class CriteriaParser {

    public static String nodesToRawString(List<ValueNode> values) {
        String concat = "";

        for(int i = 0; i < values.size(); i++){
            if(i > 0) {
                concat += ", ";
            }

            concat += values.get(i).toRawString();
        }

        return concat;
       }
}

PARSER_END(CriteriaParser)


SKIP :
{
  " "
| "\t"
| "\n"
| "\r"
| <"//" (~["\n","\r"])* ("\n"|"\r"|"\r\n")>
| <"/*" (~["*"])* "*" (~["/"] (~["*"])* "*")* "/">
}

TOKEN: {
    <KEY: "key">

    | <LPAREN: "(">
    | <RPAREN: ")">
    | <LBRACKET: "[">
    | <RBRACKET: "]">
    | <COMA: ",">

    | <QUOTED_STRING: "\"" (~["\""])* "\"" >

    | <#DIGIT: ["0" - "9"] >
    | <#SIGN:  ["-", "+"] >
    | <INTEGER: (<DIGIT>)+ >
    | <SIGNED_INTEGER: <SIGN> <INTEGER> >
    | <NUMBER: (<SIGN>)? (<INTEGER> "." <INTEGER>) >

    | <BOOLEAN: ("true"|"false")>

    | <MAPPING: "=>">
}

public ValueNode value() :
{
    ValueNode v;
}
{
    v = functionToUpperCase() {return v;}
    | v = functionToLowerCase() {return v;}
    | v = functionTakeFirstCharacters() {return v;}
    | v = functionTakeLastCharacters() {return v;}
    | v = functionConcat() {return v;}
    | v = functionTakeRegexGroup() {return v;}
    | v = functionSimpleMapping() {return v;}

    | v = valueRef() {return v;}

    | v = constant() {return v;}
    | v = constantString() {return v;}
    | v = constantBoolean() {return v;}
    | v = constantNumber() {return v;}

    {
        throw new IllegalStateException("Unsupported node");
    }
}

public ValueRefNode valueRef() #ValueRefNode :
{
    Token reference;
    String referenceNoQuote;
}
{
    "val" <LPAREN> reference = <QUOTED_STRING> <RPAREN>

    {
        referenceNoQuote = reference.image;
        referenceNoQuote = referenceNoQuote.substring(0, referenceNoQuote.length() - 1);
        referenceNoQuote = referenceNoQuote.substring(1, referenceNoQuote.length());
        jjtThis.setReference(referenceNoQuote);
        jjtThis.setRawString("val(" + reference.image + ")");

        return jjtThis;
    }
}

public ConstantNode constant() #ConstantNode :
{
    Token tokenValue;
    Object value;
}
{
    "const" <LPAREN> tokenValue = <QUOTED_STRING> <RPAREN>

    {
        value = tokenValue.image;
        value = ((String) value).substring(0, ((String) value).length() - 1);
        value = ((String) value).substring(1, ((String) value).length());
        jjtThis.setValue(value);
        jjtThis.setValueType(DataType.TEXT);
        jjtThis.setRawString("const(" + tokenValue.image + ")");

        return jjtThis;
    }
    |
    "const" <LPAREN> tokenValue = <BOOLEAN> <RPAREN>
    {
        value = tokenValue.image;
        jjtThis.setValue(Boolean.valueOf((String) value));
        jjtThis.setValueType(DataType.BOOLEAN);
        jjtThis.setRawString("const(" + tokenValue.image + ")");

        return jjtThis;
    }
    |
    "const" <LPAREN> ((tokenValue = <NUMBER>) | (tokenValue = <SIGNED_INTEGER>) | (tokenValue = <INTEGER>)) <RPAREN>
    {
        value = tokenValue.image;
        jjtThis.setValue(new BigDecimal((String) value));
        jjtThis.setValueType(DataType.NUMBER);
        jjtThis.setRawString("const(" + tokenValue.image + ")");

        return jjtThis;
    }
}

public ConstantNode constantString() #ConstantNode :
{
    Token tokenValue;
    Object value;
}
{
    tokenValue = <QUOTED_STRING>

    {
        value = tokenValue.image;
        value = ((String) value).substring(0, ((String) value).length() - 1);
        value = ((String) value).substring(1, ((String) value).length());
        jjtThis.setValue(value);
        jjtThis.setValueType(DataType.TEXT);
        jjtThis.setRawString(tokenValue.image);

        return jjtThis;
    }
}

public ConstantNode constantBoolean() #ConstantNode :
{
    Token tokenValue;
    Object value;
}
{
    tokenValue = <BOOLEAN>

    {
        value = tokenValue.image;
        jjtThis.setValue(Boolean.valueOf((String) value));
        jjtThis.setValueType(DataType.BOOLEAN);
        jjtThis.setRawString(tokenValue.image);

        return jjtThis;
    }
}

public ConstantNode constantNumber() #ConstantNode :
{
    Token tokenValue;
    Object value;
}
{
    ((tokenValue = <NUMBER>) | (tokenValue = <SIGNED_INTEGER>) | (tokenValue = <INTEGER>))

    {
        value = tokenValue.image;
        jjtThis.setValue(new BigDecimal((String) value));
        jjtThis.setValueType(DataType.NUMBER);
        jjtThis.setRawString(tokenValue.image);

        return jjtThis;
    }
}

public FunctionToUpperCaseNode functionToUpperCase() #FunctionToUpperCaseNode :
{
    ValueNode value;
}
{
    "toUpperCase" <LPAREN> value=value() <RPAREN>

    {
        jjtThis.setValue(value);
        jjtThis.setRawString("toUpperCase(" + value.toRawString() + ")");

        return jjtThis;
    }
}

public FunctionToLowerCaseNode functionToLowerCase() #FunctionToLowerCaseNode :
{
    ValueNode value;
}
{
    "toLowerCase" <LPAREN> value=value() <RPAREN>

    {
        jjtThis.setValue(value);
        jjtThis.setRawString("toLowerCase(" + value.toRawString() + ")");

        return jjtThis;
    }
}

public FunctionTakeFirstCharactersNode functionTakeFirstCharacters() #FunctionTakeFirstCharactersNode :
{
    ValueNode value;
    Token number;
}
{
    "takeFirstCharacters" <LPAREN> value=value() <COMA> number=<INTEGER> <RPAREN>

    {
        jjtThis.setValue(value);
        jjtThis.setNumber(Integer.valueOf(number.image));
        jjtThis.setRawString("takeFirstCharacters(" + value.toRawString() + ", " + number.image + ")");

        return jjtThis;
    }
}

public FunctionTakeLastCharactersNode functionTakeLastCharacters() #FunctionTakeLastCharactersNode :
{
    ValueNode value;
    Token number;
}
{
    "takeLastCharacters" <LPAREN> value=value() <COMA> number=<INTEGER> <RPAREN>

    {
        jjtThis.setValue(value);
        jjtThis.setNumber(Integer.valueOf(number.image));
        jjtThis.setRawString("takeLastCharacters(" + value.toRawString() + ", " + number.image + ")");

        return jjtThis;
    }
}

public FunctionConcatNode functionConcat() #FunctionConcatNode :
{
    List<ValueNode> values = new ArrayList<ValueNode>();
    ValueNode value;
}
{
    "concat"
    <LPAREN>
     value = value() {values.add(value);}
     ("," value = value() {values.add(value);})*
     <RPAREN>

    {
        jjtThis.setValues(values);
        jjtThis.setRawString("concat(" + nodesToRawString(values) + ")");

        return jjtThis;
    }
}

public FunctionTakeRegexGroupNode functionTakeRegexGroup() #FunctionTakeRegexGroupNode :
{
    ValueNode value;
    Token regex;
    Token groupNumber;
    String regexNoQuote;
}
{
    "takeRegexGroup" <LPAREN> value = value() <COMA> regex = <QUOTED_STRING> <COMA> groupNumber = <INTEGER> <RPAREN>

    {
        jjtThis.setValue(value);

        regexNoQuote = regex.image;
        regexNoQuote = regexNoQuote.substring(0, regexNoQuote.length() - 1);
        regexNoQuote = regexNoQuote.substring(1, regexNoQuote.length());

        jjtThis.setRegex(regexNoQuote);
        jjtThis.setGroupNumber(Integer.valueOf(groupNumber.image));
        jjtThis.setRawString("takeRegexGroup(" + value.toRawString() + ", " + regex + ", " + groupNumber.image + ")");

        return jjtThis;
    }
}

public FunctionSimpleMappingNode functionSimpleMapping() #FunctionSimpleMappingNode :
{
    ValueNode value;
    Token regex;
    Token groupNumber;
    String regexNoQuote;
}
{
    "takeRegexGroup" <LPAREN> value = value() <COMA> regex = <QUOTED_STRING> <COMA> groupNumber = <INTEGER> <RPAREN>

    {
        jjtThis.setValue(value);

        regexNoQuote = regex.image;
        regexNoQuote = regexNoQuote.substring(0, regexNoQuote.length() - 1);
        regexNoQuote = regexNoQuote.substring(1, regexNoQuote.length());

        jjtThis.setRegex(regexNoQuote);
        jjtThis.setGroupNumber(Integer.valueOf(groupNumber.image));
        jjtThis.setRawString("takeRegexGroup(" + value.toRawString() + ", " + regex + ", " + groupNumber.image + ")");

        return jjtThis;
    }
}

public KeyNode key() #KeyNode:
{
    java.util.List<ValueNode> values = new java.util.ArrayList<ValueNode>();
    ValueNode value;
}
{
    (
        <KEY> <LPAREN>
        value = value() {values.add(value);}
        ("," value = value() {values.add(value);})*
        <RPAREN> <EOF>
    )*
    <EOF>
    {
        jjtThis.setValues(values);
        jjtThis.setRawString("key(" + nodesToRawString(values) + ")");

        return jjtThis;
    }
}