Token token = tokens.poll(); if(token.getToken().equals("{")) { output.push(parse(string, tokens, false)); } else if(token.getToken().equals("}")) { if(topLevel) { throw error(string, token.getPosition(), "Unexpected token"); handleLineEnd(string, operatorStack, output, blocks); } else if (isSpecialChar(token.getToken())) { if (token.getToken().equals("(")) { operatorStack.push(token); Token op = operatorStack.pop(); if (op == null) { throw error(string, token.getPosition(), "Unexpected end of input"); } else if (op.getToken().equals("(")) { break; if (isOperator(token.getToken()) && !token.getToken().equals(ELSE)) { int prec = precedence(token.getToken()); Token top = operatorStack.peek(); while (top != null) { int exitingPrec = precedence(top.getToken()); if (prec <= exitingPrec) { output.push(new OperatorNode(operatorStack.pop())); output.push(parseExpression(string, token, tokens));
private static Predicate handlePredicateExpressionNode(String contents, ExpressionNode node, Map<String, PredicateBuilder> handlerBuilders, ExchangeAttributeParser parser) { Token token = node.getToken(); PredicateBuilder builder = handlerBuilders.get(token.getToken()); if (builder == null) { throw error(contents, token.getPosition(), "no predicate named " + token.getToken() + " known predicates are " + handlerBuilders.keySet()); } Map<String, Object> parameters = new HashMap<>(); for(Map.Entry<String, Node> val : node.getValues().entrySet()) { String name = val.getKey(); if(name == null) { if(builder.defaultParameter() == null) { throw error(contents, token.getPosition(), "default parameter not supported"); } name = builder.defaultParameter(); } Class<?> type = builder.parameters().get(name); if(type == null) { throw error(contents, val.getValue().getToken().getPosition(), "unknown parameter " + name); } if(val.getValue() instanceof ValueNode) { parameters.put(name, coerceToType(contents, val.getValue().getToken(), type, parser)); } else if(val.getValue() instanceof ArrayNode) { parameters.put(name, readArrayType(contents, name, (ArrayNode)val.getValue(), parser, type)); } else { throw error(contents, val.getValue().getToken().getPosition(), "unexpected node " + val.getValue()); } } return builder.build(parameters); }
private static void handleLineEnd(String string, Deque<Token> operatorStack, Deque<Node> output, List<Node> blocks) { while (!operatorStack.isEmpty()) { Token op = operatorStack.pop(); if (op.getToken().equals(")")) { throw error(string, string.length(), "Mismatched parenthesis"); } output.push(new OperatorNode(op)); } if(output.isEmpty()) { return; } //now we have our tokens for this line Node predicate = collapseOutput(output.pop(), output); if (!output.isEmpty()) { throw error(string, output.getFirst().getToken().getPosition(), "Invalid expression"); } blocks.add(predicate); }
public static List<PredicatedHandler> parse(final String contents, final ClassLoader classLoader) { Deque<Token> tokens = tokenize(contents); Node node = parse(contents, tokens); Map<String, PredicateBuilder> predicateBuilders = loadPredicateBuilders(classLoader); Map<String, HandlerBuilder> handlerBuilders = loadHandlerBuilders(classLoader); final ExchangeAttributeParser attributeParser = ExchangeAttributes.parser(classLoader); return handleNode(contents, node, predicateBuilders, handlerBuilders, attributeParser); }
public static Predicate parsePredicate(String string, ClassLoader classLoader) { Deque<Token> tokens = tokenize(string); Node node = parse(string, tokens); Map<String, PredicateBuilder> predicateBuilders = loadPredicateBuilders(classLoader); final ExchangeAttributeParser attributeParser = ExchangeAttributes.parser(classLoader); return handlePredicateNode(string, node, predicateBuilders, attributeParser); }
public static HandlerWrapper parseHandler(String string, ClassLoader classLoader) { Deque<Token> tokens = tokenize(string); Node node = parse(string, tokens); Map<String, HandlerBuilder> handlerBuilders = loadHandlerBuilders(classLoader); final ExchangeAttributeParser attributeParser = ExchangeAttributes.parser(classLoader); return handleHandlerNode(string, (ExpressionNode)node, handlerBuilders, attributeParser); } private static List<PredicatedHandler> handleNode(String contents, Node node, Map<String, PredicateBuilder> predicateBuilders, Map<String, HandlerBuilder> handlerBuilders, ExchangeAttributeParser attributeParser) {
next = tokens.poll(); if (next == null) { throw error(string, string.length(), "Unexpected end of input"); return handleSingleArrayValue(string, token, tokens, endChar); throw error(string, string.length(), "Unexpected end of input"); return handleSingleValue(token, next); } else if (equals.getToken().equals(",")) { tokens.push(equals); tokens.push(next); return handleSingleVarArgsValue(string, token, tokens, endChar); throw error(string, equals.getPosition(), "Unexpected token"); throw error(string, string.length(), "Unexpected end of input"); values.put(next.getToken(), new ArrayNode(value, readArrayType(string, tokens,"}"))); } else { if (isOperator(value.getToken()) || isSpecialChar(value.getToken())) { throw error(string, value.getPosition(), "Unexpected token"); throw error(string, string.length(), "Unexpected end of input"); throw error(string, string.length(), "Expecting , or " + endChar); throw error(string, string.length(), "Unexpected end of input");
public static List<PredicatedHandler> parse(final File file, final ClassLoader classLoader) { return parse(file.toPath(), classLoader); }
private static List<PredicatedHandler> handleNode(String contents, Node node, Map<String, PredicateBuilder> predicateBuilders, Map<String, HandlerBuilder> handlerBuilders, ExchangeAttributeParser attributeParser) { if(node instanceof BlockNode) { return handleBlockNode(contents, (BlockNode) node, predicateBuilders, handlerBuilders, attributeParser); } else if(node instanceof ExpressionNode) { HandlerWrapper handler = handleHandlerNode(contents, (ExpressionNode) node, handlerBuilders, attributeParser); return Collections.singletonList(new PredicatedHandler(Predicates.truePredicate(), handler)); } else if(node instanceof PredicateOperatorNode) { return Collections.singletonList(handlePredicateOperatorNode(contents, (PredicateOperatorNode)node, predicateBuilders, handlerBuilders, attributeParser)); } else { throw error(contents, node.getToken().getPosition(), "unexpected token " + node.getToken()); } }
private static HandlerWrapper handlePredicatedAction(String contents, Node node, Map<String, PredicateBuilder> predicateBuilders, Map<String, HandlerBuilder> handlerBuilders, ExchangeAttributeParser parser) { if(node instanceof ExpressionNode) { return handleHandlerNode(contents, (ExpressionNode) node, handlerBuilders, parser); } else if(node instanceof BlockNode) { List<PredicatedHandler> handlers = handleBlockNode(contents, (BlockNode) node, predicateBuilders, handlerBuilders, parser); return new PredicatesHandler.Wrapper(handlers, false); } else { throw error(contents, node.getToken().getPosition(), "unexpected token " + node.getToken()); } }
private static Predicate handlePredicateNode(String contents, Node node, Map<String, PredicateBuilder> handlerBuilders, ExchangeAttributeParser parser) { if(node instanceof AndNode) { AndNode andNode = (AndNode)node; return Predicates.and(handlePredicateNode(contents, andNode.getLeft(), handlerBuilders, parser), handlePredicateNode(contents, andNode.getRight(), handlerBuilders, parser)); } else if(node instanceof OrNode) { OrNode orNode = (OrNode)node; return Predicates.or(handlePredicateNode(contents, orNode.getLeft(), handlerBuilders, parser), handlePredicateNode(contents, orNode.getRight(), handlerBuilders, parser)); } else if(node instanceof NotNode) { NotNode orNode = (NotNode)node; return Predicates.not(handlePredicateNode(contents, orNode.getNode(), handlerBuilders, parser)); } else if(node instanceof ExpressionNode) { return handlePredicateExpressionNode(contents, (ExpressionNode) node, handlerBuilders, parser); }else if(node instanceof OperatorNode) { switch (node.getToken().getToken()) { case TRUE: { return Predicates.truePredicate(); } case FALSE: { return Predicates.falsePredicate(); } } } throw error(contents, node.getToken().getPosition(), "unexpected node " + node); }
private static Object readArrayType(final String string, String paramName, ArrayNode value, ExchangeAttributeParser parser, Class type) { if (!type.isArray()) { throw error(string, value.getToken().getPosition(), "parameter is not an array type " + paramName); } Class<?> componentType = type.getComponentType(); final List<Object> values = new ArrayList<>(); for(Token token : value.getValues()) { values.add(coerceToType(string, token, componentType, parser)); } Object array = Array.newInstance(componentType, values.size()); for (int i = 0; i < values.size(); ++i) { Array.set(array, i, values.get(i)); } return array; }
private static PredicatedHandler handlePredicateOperatorNode(String contents, PredicateOperatorNode node, Map<String, PredicateBuilder> predicateBuilders, Map<String, HandlerBuilder> handlerBuilders, ExchangeAttributeParser parser) { Predicate predicate = handlePredicateNode(contents, node.getLeft(), predicateBuilders, parser); HandlerWrapper ret = handlePredicatedAction(contents, node.getRight(), predicateBuilders, handlerBuilders, parser); HandlerWrapper elseBranch = null; if(node.getElseBranch() != null) { elseBranch = handlePredicatedAction(contents, node.getElseBranch(), predicateBuilders, handlerBuilders, parser); } return new PredicatedHandler(predicate, ret, elseBranch); }
private static Node handleSingleArrayValue(final String string, final Token builder, final Deque<Token> tokens, String endChar) { List<Token> array = readArrayType(string, tokens, "}"); Token close = tokens.poll(); if (!close.getToken().equals(endChar)) { throw error(string, close.getPosition(), "expected " + endChar); } return new ExpressionNode(builder, Collections.<String, Node>singletonMap(null, new ArrayNode(builder, array))); }
private static List<Token> readArrayType(final String string, final Deque<Token> tokens, String expectedEndToken) { final List<Token> values = new ArrayList<>(); Token token = tokens.poll(); if(token.getToken().equals(expectedEndToken)) { return Collections.emptyList(); } while (token != null) { Token commaOrEnd = tokens.poll(); values.add(token); if (commaOrEnd.getToken().equals(expectedEndToken)) { return values; } else if (!commaOrEnd.getToken().equals(",")) { throw error(string, commaOrEnd.getPosition(), "expected either , or " + expectedEndToken); } token = tokens.poll(); } throw error(string, string.length(), "unexpected end of input in array"); }
private static List<PredicatedHandler> handleBlockNode(String contents, BlockNode node, Map<String, PredicateBuilder> predicateBuilders, Map<String, HandlerBuilder> handlerBuilders, ExchangeAttributeParser parser) { List<PredicatedHandler> ret = new ArrayList<>(); for(Node line : node.getBlock()) { ret.addAll(handleNode(contents, line, predicateBuilders, handlerBuilders, parser)); } return ret; }
OperatorNode node = (OperatorNode) token; if (node.token.getToken().equals(AND)) { Node n1 = collapseOutput(tokens.pop(), tokens); Node n2 = collapseOutput(tokens.pop(), tokens); return new AndNode(token.getToken(), n2, n1); } else if (node.token.getToken().equals(OR)) { Node n1 = collapseOutput(tokens.pop(), tokens); Node n2 = collapseOutput(tokens.pop(), tokens); return new OrNode(token.getToken(), n2, n1); } else if (node.token.getToken().equals(NOT)) { Node n1 = collapseOutput(tokens.pop(), tokens); return new NotNode(token.getToken(), n1); } else if (node.token.getToken().equals(ARROW)) { Node n1 = collapseOutput(tokens.pop(), tokens); Node n2 = null; Node elseBranch = null; if(popped.getToken().getToken().equals(ELSE)) { elseBranch = n1; n1 = collapseOutput(tokens.pop(), tokens); n2 = collapseOutput(tokens.pop(), tokens); } else { n2 = collapseOutput(popped, tokens);
next = tokens.poll(); if (next == null) { throw error(string, string.length(), "Unexpected end of input"); return handleSingleArrayValue(string, token, tokens, endChar); throw error(string, string.length(), "Unexpected end of input"); return handleSingleValue(token, next); } else if (equals.getToken().equals(",")) { tokens.push(equals); tokens.push(next); return handleSingleVarArgsValue(string, token, tokens, endChar); throw error(string, equals.getPosition(), "Unexpected token"); throw error(string, string.length(), "Unexpected end of input"); values.put(next.getToken(), new ArrayNode(value, readArrayType(string, tokens,"}"))); } else { if (isOperator(value.getToken()) || isSpecialChar(value.getToken())) { throw error(string, value.getPosition(), "Unexpected token"); throw error(string, string.length(), "Unexpected end of input"); throw error(string, string.length(), "Expecting , or " + endChar); throw error(string, string.length(), "Unexpected end of input");
public static List<PredicatedHandler> parse(final String contents, final ClassLoader classLoader) { Deque<Token> tokens = tokenize(contents); Node node = parse(contents, tokens); Map<String, PredicateBuilder> predicateBuilders = loadPredicateBuilders(classLoader); Map<String, HandlerBuilder> handlerBuilders = loadHandlerBuilders(classLoader); final ExchangeAttributeParser attributeParser = ExchangeAttributes.parser(classLoader); return handleNode(contents, node, predicateBuilders, handlerBuilders, attributeParser); }
public static Predicate parsePredicate(String string, ClassLoader classLoader) { Deque<Token> tokens = tokenize(string); Node node = parse(string, tokens); Map<String, PredicateBuilder> predicateBuilders = loadPredicateBuilders(classLoader); final ExchangeAttributeParser attributeParser = ExchangeAttributes.parser(classLoader); return handlePredicateNode(string, node, predicateBuilders, attributeParser); }