| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| |
| #include "qmf/exceptions.h" |
| #include "qmf/Expression.h" |
| #include <iostream> |
| |
| using namespace std; |
| using namespace qmf; |
| using namespace qpid::types; |
| |
| Expression::Expression(const Variant::List& expr) |
| { |
| static int level(0); |
| level++; |
| Variant::List::const_iterator iter(expr.begin()); |
| string op(iter->asString()); |
| iter++; |
| |
| if (op == "not") logicalOp = LOGICAL_NOT; |
| else if (op == "and") logicalOp = LOGICAL_AND; |
| else if (op == "or") logicalOp = LOGICAL_OR; |
| else { |
| logicalOp = LOGICAL_ID; |
| if (op == "eq") boolOp = BOOL_EQ; |
| else if (op == "ne") boolOp = BOOL_NE; |
| else if (op == "lt") boolOp = BOOL_LT; |
| else if (op == "le") boolOp = BOOL_LE; |
| else if (op == "gt") boolOp = BOOL_GT; |
| else if (op == "ge") boolOp = BOOL_GE; |
| else if (op == "re_match") boolOp = BOOL_RE_MATCH; |
| else if (op == "exists") boolOp = BOOL_EXISTS; |
| else if (op == "true") boolOp = BOOL_TRUE; |
| else if (op == "false") boolOp = BOOL_FALSE; |
| else |
| throw QmfException("Invalid operator in predicate expression"); |
| } |
| |
| if (logicalOp == LOGICAL_ID) { |
| switch (boolOp) { |
| case BOOL_EQ: |
| case BOOL_NE: |
| case BOOL_LT: |
| case BOOL_LE: |
| case BOOL_GT: |
| case BOOL_GE: |
| case BOOL_RE_MATCH: |
| // |
| // Binary operator: get two operands. |
| // |
| operandCount = 2; |
| break; |
| |
| case BOOL_EXISTS: |
| // |
| // Unary operator: get one operand. |
| // |
| operandCount = 1; |
| break; |
| |
| case BOOL_TRUE: |
| case BOOL_FALSE: |
| // |
| // Literal operator: no operands. |
| // |
| operandCount = 0; |
| break; |
| } |
| |
| for (int idx = 0; idx < operandCount; idx++) { |
| if (iter == expr.end()) |
| throw QmfException("Too few operands for operation: " + op); |
| if (iter->getType() == VAR_STRING) { |
| quoted[idx] = false; |
| operands[idx] = *iter; |
| } else if (iter->getType() == VAR_LIST) { |
| const Variant::List& sublist(iter->asList()); |
| Variant::List::const_iterator subIter(sublist.begin()); |
| if (subIter != sublist.end() && subIter->asString() == "quote") { |
| quoted[idx] = true; |
| subIter++; |
| if (subIter != sublist.end()) { |
| operands[idx] = *subIter; |
| subIter++; |
| if (subIter != sublist.end()) |
| throw QmfException("Extra tokens at end of 'quote'"); |
| } |
| } else |
| throw QmfException("Expected '[quote, <token>]'"); |
| } else |
| throw QmfException("Expected string or list as operand for: " + op); |
| iter++; |
| } |
| |
| if (iter != expr.end()) |
| throw QmfException("Too many operands for operation: " + op); |
| |
| } else { |
| // |
| // This is a logical expression, collect sub-expressions |
| // |
| while (iter != expr.end()) { |
| if (iter->getType() != VAR_LIST) |
| throw QmfException("Operands of " + op + " must be lists"); |
| expressionList.push_back(boost::shared_ptr<Expression>(new Expression(iter->asList()))); |
| iter++; |
| } |
| } |
| level--; |
| } |
| |
| |
| bool Expression::evaluate(const Variant::Map& data) const |
| { |
| list<boost::shared_ptr<Expression> >::const_iterator iter; |
| |
| switch (logicalOp) { |
| case LOGICAL_ID: |
| return boolEval(data); |
| |
| case LOGICAL_NOT: |
| for (iter = expressionList.begin(); iter != expressionList.end(); iter++) |
| if ((*iter)->evaluate(data)) |
| return false; |
| return true; |
| |
| case LOGICAL_AND: |
| for (iter = expressionList.begin(); iter != expressionList.end(); iter++) |
| if (!(*iter)->evaluate(data)) |
| return false; |
| return true; |
| |
| case LOGICAL_OR: |
| for (iter = expressionList.begin(); iter != expressionList.end(); iter++) |
| if ((*iter)->evaluate(data)) |
| return true; |
| return false; |
| } |
| |
| return false; |
| } |
| |
| |
| bool Expression::boolEval(const Variant::Map& data) const |
| { |
| Variant val[2]; |
| bool exists[2]; |
| |
| for (int idx = 0; idx < operandCount; idx++) { |
| if (quoted[idx]) { |
| exists[idx] = true; |
| val[idx] = operands[idx]; |
| } else { |
| Variant::Map::const_iterator mIter(data.find(operands[idx].asString())); |
| if (mIter == data.end()) { |
| exists[idx] = false; |
| } else { |
| exists[idx] = true; |
| val[idx] = mIter->second; |
| } |
| } |
| } |
| |
| switch (boolOp) { |
| case BOOL_EQ: return (exists[0] && exists[1] && (val[0].asString() == val[1].asString())); |
| case BOOL_NE: return (exists[0] && exists[1] && (val[0].asString() != val[1].asString())); |
| case BOOL_LT: return (exists[0] && exists[1] && lessThan(val[0], val[1])); |
| case BOOL_LE: return (exists[0] && exists[1] && lessEqual(val[0], val[1])); |
| case BOOL_GT: return (exists[0] && exists[1] && greaterThan(val[0], val[1])); |
| case BOOL_GE: return (exists[0] && exists[1] && greaterEqual(val[0], val[1])); |
| case BOOL_RE_MATCH: return false; // TODO |
| case BOOL_EXISTS: return exists[0]; |
| case BOOL_TRUE: return true; |
| case BOOL_FALSE: return false; |
| } |
| |
| return false; |
| } |
| |
| bool Expression::lessThan(const Variant& left, const Variant& right) const |
| { |
| switch (left.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| switch (right.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| return left.asInt64() < right.asInt64(); |
| case VAR_STRING: |
| try { |
| return left.asInt64() < right.asInt64(); |
| } catch (std::exception&) {} |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| case VAR_FLOAT: case VAR_DOUBLE: |
| switch (right.getType()) { |
| case VAR_FLOAT: case VAR_DOUBLE: |
| return left.asDouble() < right.asDouble(); |
| case VAR_STRING: |
| try { |
| return left.asDouble() < right.asDouble(); |
| } catch (std::exception&) {} |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| case VAR_STRING: |
| switch (right.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| try { |
| return left.asInt64() < right.asInt64(); |
| } catch (std::exception&) {} |
| break; |
| |
| case VAR_FLOAT: case VAR_DOUBLE: |
| try { |
| return left.asDouble() < right.asDouble(); |
| } catch (std::exception&) {} |
| break; |
| |
| case VAR_STRING: |
| return left.asString() < right.asString(); |
| default: |
| break; |
| } |
| default: |
| break; |
| } |
| |
| return false; |
| } |
| |
| |
| bool Expression::lessEqual(const Variant& left, const Variant& right) const |
| { |
| switch (left.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| switch (right.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| return left.asInt64() <= right.asInt64(); |
| case VAR_STRING: |
| try { |
| return left.asInt64() <= right.asInt64(); |
| } catch (std::exception&) {} |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| case VAR_FLOAT: case VAR_DOUBLE: |
| switch (right.getType()) { |
| case VAR_FLOAT: case VAR_DOUBLE: |
| return left.asDouble() <= right.asDouble(); |
| case VAR_STRING: |
| try { |
| return left.asDouble() <= right.asDouble(); |
| } catch (std::exception&) {} |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| case VAR_STRING: |
| switch (right.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| try { |
| return left.asInt64() <= right.asInt64(); |
| } catch (std::exception&) {} |
| break; |
| |
| case VAR_FLOAT: case VAR_DOUBLE: |
| try { |
| return left.asDouble() <= right.asDouble(); |
| } catch (std::exception&) {} |
| break; |
| |
| case VAR_STRING: |
| return left.asString() <= right.asString(); |
| default: |
| break; |
| } |
| default: |
| break; |
| } |
| |
| return false; |
| } |
| |
| |
| bool Expression::greaterThan(const Variant& left, const Variant& right) const |
| { |
| switch (left.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| switch (right.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| return left.asInt64() > right.asInt64(); |
| case VAR_STRING: |
| try { |
| return left.asInt64() > right.asInt64(); |
| } catch (std::exception&) {} |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| case VAR_FLOAT: case VAR_DOUBLE: |
| switch (right.getType()) { |
| case VAR_FLOAT: case VAR_DOUBLE: |
| return left.asDouble() > right.asDouble(); |
| case VAR_STRING: |
| try { |
| return left.asDouble() > right.asDouble(); |
| } catch (std::exception&) {} |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| case VAR_STRING: |
| switch (right.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| try { |
| return left.asInt64() > right.asInt64(); |
| } catch (std::exception&) {} |
| break; |
| |
| case VAR_FLOAT: case VAR_DOUBLE: |
| try { |
| return left.asDouble() > right.asDouble(); |
| } catch (std::exception&) {} |
| break; |
| |
| case VAR_STRING: |
| return left.asString() > right.asString(); |
| default: |
| break; |
| } |
| default: |
| break; |
| } |
| |
| return false; |
| } |
| |
| |
| bool Expression::greaterEqual(const Variant& left, const Variant& right) const |
| { |
| switch (left.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| switch (right.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| return left.asInt64() >= right.asInt64(); |
| case VAR_STRING: |
| try { |
| return left.asInt64() >= right.asInt64(); |
| } catch (std::exception&) {} |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| case VAR_FLOAT: case VAR_DOUBLE: |
| switch (right.getType()) { |
| case VAR_FLOAT: case VAR_DOUBLE: |
| return left.asDouble() >= right.asDouble(); |
| case VAR_STRING: |
| try { |
| return left.asDouble() >= right.asDouble(); |
| } catch (std::exception&) {} |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| case VAR_STRING: |
| switch (right.getType()) { |
| case VAR_UINT8: case VAR_UINT16: case VAR_UINT32: case VAR_UINT64: |
| case VAR_INT8: case VAR_INT16: case VAR_INT32: case VAR_INT64: |
| try { |
| return left.asInt64() >= right.asInt64(); |
| } catch (std::exception&) {} |
| break; |
| |
| case VAR_FLOAT: case VAR_DOUBLE: |
| try { |
| return left.asDouble() >= right.asDouble(); |
| } catch (std::exception&) {} |
| break; |
| |
| case VAR_STRING: |
| return left.asString() >= right.asString(); |
| default: |
| break; |
| } |
| default: |
| break; |
| } |
| |
| return false; |
| } |
| |
| |
