001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.language.simple.ast; 018 019 import org.apache.camel.Exchange; 020 import org.apache.camel.Expression; 021 import org.apache.camel.Predicate; 022 import org.apache.camel.builder.PredicateBuilder; 023 import org.apache.camel.language.simple.types.LogicalOperatorType; 024 import org.apache.camel.language.simple.types.SimpleParserException; 025 import org.apache.camel.language.simple.types.SimpleToken; 026 import org.apache.camel.util.ExpressionToPredicateAdapter; 027 import org.apache.camel.util.ObjectHelper; 028 029 /** 030 * Represents a logical expression in the AST 031 */ 032 public class LogicalExpression extends BaseSimpleNode { 033 034 private LogicalOperatorType operator; 035 private SimpleNode left; 036 private SimpleNode right; 037 038 public LogicalExpression(SimpleToken token) { 039 super(token); 040 operator = LogicalOperatorType.asOperator(token.getText()); 041 } 042 043 @Override 044 public String toString() { 045 return left + " " + token.getText() + " " + right; 046 } 047 048 public boolean acceptLeftNode(SimpleNode lef) { 049 this.left = lef; 050 return true; 051 } 052 053 public boolean acceptRightNode(SimpleNode right) { 054 this.right = right; 055 return true; 056 } 057 058 public LogicalOperatorType getOperator() { 059 return operator; 060 } 061 062 @Override 063 public Expression createExpression(String expression) { 064 ObjectHelper.notNull(left, "left node", this); 065 ObjectHelper.notNull(right, "right node", this); 066 067 final Expression leftExp = left.createExpression(expression); 068 final Expression rightExp = right.createExpression(expression); 069 070 if (operator == LogicalOperatorType.AND) { 071 return createAndExpression(leftExp, rightExp); 072 } else if (operator == LogicalOperatorType.OR) { 073 return createOrExpression(leftExp, rightExp); 074 } 075 076 throw new SimpleParserException("Unknown logical operator " + operator, token.getIndex()); 077 } 078 079 private Expression createAndExpression(final Expression leftExp, final Expression rightExp) { 080 return new Expression() { 081 @Override 082 public <T> T evaluate(Exchange exchange, Class<T> type) { 083 Predicate predicate = ExpressionToPredicateAdapter.toPredicate(leftExp); 084 predicate = PredicateBuilder.and(predicate, ExpressionToPredicateAdapter.toPredicate(rightExp)); 085 086 boolean answer = predicate.matches(exchange); 087 return exchange.getContext().getTypeConverter().convertTo(type, answer); 088 } 089 090 @Override 091 public String toString() { 092 return left + " " + token.getText() + " " + right; 093 } 094 }; 095 } 096 097 private Expression createOrExpression(final Expression leftExp, final Expression rightExp) { 098 return new Expression() { 099 @Override 100 public <T> T evaluate(Exchange exchange, Class<T> type) { 101 Predicate predicate = ExpressionToPredicateAdapter.toPredicate(leftExp); 102 predicate = PredicateBuilder.or(predicate, ExpressionToPredicateAdapter.toPredicate(rightExp)); 103 104 boolean answer = predicate.matches(exchange); 105 return exchange.getContext().getTypeConverter().convertTo(type, answer); 106 } 107 108 @Override 109 public String toString() { 110 return left + " " + token.getText() + " " + right; 111 } 112 }; 113 } 114 115 }