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); }
@Override public String toString() { return value.getToken(); }
public static HandlerWrapper parse(String string, final ClassLoader classLoader) { return PredicatedHandlersParser.parseHandler(string, classLoader); }
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 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 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))); }
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); }
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); }
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()); } }
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) {
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 Node handleSingleVarArgsValue(final String string, final Token expressionName, final Deque<Token> tokens, String endChar) { List<Token> array = readArrayType(string, tokens, endChar); return new ExpressionNode(expressionName, Collections.<String, Node>singletonMap(null, new ArrayNode(expressionName, array))); }
public PredicatesHandler addPredicatedHandler(final PredicatedHandler handler) { return addPredicatedHandler(handler.getPredicate(), handler.getHandler(), handler.getElseHandler()); }
public static List<PredicatedHandler> parse(final File file, final ClassLoader classLoader) { return parse(file.toPath(), classLoader); }
private static Node handleSingleValue(final Token token, final Token next) { return new ExpressionNode(token, Collections.<String, Node>singletonMap(null, new ValueNode(next))); }
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; }
@Override public HttpHandler wrap(HttpHandler handler) { PredicatesHandler h = new PredicatesHandler(handler, outerHandler); for(PredicatedHandler pred : handlers) { h.addPredicatedHandler(pred.getPredicate(), pred.getHandler()); } return h; } }
public static final Predicate parse(String string, final ClassLoader classLoader) { return PredicatedHandlersParser.parsePredicate(string, classLoader); }
public static List<PredicatedHandler> parse(final InputStream inputStream, final ClassLoader classLoader) { return parse(FileUtils.readFile(inputStream), classLoader); }