Examples with SimpleNode org.apache.camel.language.simple.ast.SimpleNode used on opensource projects

Example 6 with SimpleNode

use of org.apache.camel.language.simple.ast.SimpleNode in project camel by apache.

the class SimplePredicateParser method createPredicates.

/**
     * Creates the {@link Predicate}s from the AST nodes.
     *
     * @return the created {@link Predicate}s, is never <tt>null</tt>.
     */
private List<Predicate> createPredicates() {
    List<Predicate> answer = new ArrayList<Predicate>();
    for (SimpleNode node : nodes) {
        Expression exp = node.createExpression(expression);
        if (exp != null) {
            Predicate predicate = ExpressionToPredicateAdapter.toPredicate(exp);
            answer.add(predicate);
        }
    }
    return answer;
}

Example 7 with SimpleNode

use of org.apache.camel.language.simple.ast.SimpleNode in project camel by apache.

the class BaseSimpleParser method prepareUnaryExpressions.

/**
     * Prepares unary expressions.
     * <p/>
     * This process prepares the unary expressions in the AST. This is done
     * by linking the unary operator with the left hand side node,
     * to have the AST graph updated and prepared properly.
     * <p/>
     * So when the AST node is later used to create the {@link org.apache.camel.Predicate}s
     * or {@link org.apache.camel.Expression}s to be used by Camel then the AST graph
     * has a linked and prepared graph of nodes which represent the input expression.
     */
protected void prepareUnaryExpressions() {
    Stack<SimpleNode> stack = new Stack<SimpleNode>();
    for (SimpleNode node : nodes) {
        if (node instanceof UnaryExpression) {
            UnaryExpression token = (UnaryExpression) node;
            // remember the logical operator
            String operator = token.getOperator().toString();
            SimpleNode previous = stack.isEmpty() ? null : stack.pop();
            if (previous == null) {
                throw new SimpleParserException("Unary operator " + operator + " has no left hand side token", token.getToken().getIndex());
            } else {
                token.acceptLeft(previous);
            }
        }
        stack.push(node);
    }
    // replace nodes from the stack
    nodes.clear();
    nodes.addAll(stack);
}

Example 8 with SimpleNode

use of org.apache.camel.language.simple.ast.SimpleNode in project camel by apache.

the class SimplePredicateParser method createNode.

/**
     * Creates a node from the given token
     *
     * @param token         the token
     * @param startSingle   state of single quoted blocks
     * @param startDouble   state of double quoted blocks
     * @param startFunction state of function blocks
     * @return the created node, or <tt>null</tt> to let a default node be created instead.
     */
private SimpleNode createNode(SimpleToken token, AtomicBoolean startSingle, AtomicBoolean startDouble, AtomicBoolean startFunction) {
    if (token.getType().isFunctionStart()) {
        startFunction.set(true);
        return new SimpleFunctionStart(token);
    } else if (token.getType().isFunctionEnd()) {
        startFunction.set(false);
        return new SimpleFunctionEnd(token);
    }
    // as we want all the tokens to be literal instead
    if (startFunction.get()) {
        return null;
    }
    // okay so far we also want to support quotes
    if (token.getType().isSingleQuote()) {
        SimpleNode answer;
        boolean start = startSingle.get();
        if (!start) {
            answer = new SingleQuoteStart(token);
        } else {
            answer = new SingleQuoteEnd(token);
        }
        // flip state on start/end flag
        startSingle.set(!start);
        return answer;
    } else if (token.getType().isDoubleQuote()) {
        SimpleNode answer;
        boolean start = startDouble.get();
        if (!start) {
            answer = new DoubleQuoteStart(token);
        } else {
            answer = new DoubleQuoteEnd(token);
        }
        // flip state on start/end flag
        startDouble.set(!start);
        return answer;
    }
    // as we want to only support embedded functions and all other kinds to be literal tokens
    if (startSingle.get() || startDouble.get()) {
        return null;
    }
    // and the special null value as well
    if (token.getType().isUnary()) {
        return new UnaryExpression(token);
    } else if (token.getType().isBinary()) {
        return new BinaryExpression(token);
    } else if (token.getType().isLogical()) {
        return new LogicalExpression(token);
    } else if (token.getType().isNullValue()) {
        return new NullExpression(token);
    }
    // by returning null, we will let the parser determine what to do
    return null;
}