OpenDDS::DCPS::FilterEvaluator

OpenDDS::DCPS::FilterEvaluator Class Reference

#include <FilterEvaluator.h>

Inheritance diagram for OpenDDS::DCPS::FilterEvaluator:

Inheritance graph
[legend]
Collaboration diagram for OpenDDS::DCPS::FilterEvaluator:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 FilterEvaluator (const char *filter, bool allowOrderBy)
 FilterEvaluator (const AstNodeWrapper &yardNode)
 ~FilterEvaluator ()
 OPENDDS_VECTOR (OPENDDS_STRING) getOrderBys() const
bool hasFilter () const
bool usesExtendedGrammar () const
template<typename T>
bool eval (const T &sample, const DDS::StringSeq &params) const
bool eval (ACE_Message_Block *serializedSample, bool swap_bytes, bool cdr_encap, const MetaStruct &meta, const DDS::StringSeq &params) const

Private Member Functions

 FilterEvaluator (const FilterEvaluator &)
FilterEvaluator & operator= (const FilterEvaluator &)
EvalNode * walkAst (const AstNodeWrapper &node)
Operand * walkOperand (const AstNodeWrapper &node)
bool eval_i (DataForEval &data) const
 OPENDDS_VECTOR (OPENDDS_STRING) order_bys_

Private Attributes

bool extended_grammar_
EvalNode * filter_root_

Classes

struct  AstNodeWrapper
 keeps the details of yard out of the FilterEvaluator header file More...
struct  DataForEval
struct  DeserializedForEval
class  EvalNode
class  Operand
struct  SerializedForEval

Detailed Description

Definition at line 74 of file FilterEvaluator.h.

Constructor & Destructor Documentation

OpenDDS::DCPS::FilterEvaluator::FilterEvaluator ( const char *  filter,
bool  allowOrderBy 
)

Definition at line 41 of file FilterEvaluator.cpp.

References filter_root_, FACE::TS::parser, OpenDDS::DCPS::reportErrors(), OpenDDS::DCPS::toString(), and walkAst().

00042   : extended_grammar_(false)
00043   , filter_root_(0)
00044 {
00045   const char* out = filter + std::strlen(filter);
00046   yard::SimpleTextParser parser(filter, out);
00047   if (!(allowOrderBy ? parser.Parse<QueryCompleteInput>()
00048       : parser.Parse<FilterCompleteInput>())) {
00049     reportErrors(parser, filter);
00050   }
00051 
00052   bool found_order_by = false;
00053   for (AstNode* iter = parser.GetAstRoot()->GetFirstChild(); iter;
00054       iter = iter->GetSibling()) {
00055     if (iter->TypeMatches<ORDERBY>()) {
00056       found_order_by = true;
00057     } else if (found_order_by && iter->TypeMatches<FieldName>()) {
00058       order_bys_.push_back(toString(iter));
00059     } else {
00060       filter_root_ = walkAst(iter);
00061     }
00062   }
00063 }

OpenDDS::DCPS::FilterEvaluator::FilterEvaluator ( const AstNodeWrapper &  yardNode  )  [explicit]

Definition at line 65 of file FilterEvaluator.cpp.

00066   : extended_grammar_(false)
00067   , filter_root_(walkAst(yardNode))
00068 {
00069 }

OpenDDS::DCPS::FilterEvaluator::~FilterEvaluator (  ) 

Definition at line 133 of file FilterEvaluator.cpp.

References filter_root_.

00134 {
00135   delete filter_root_;
00136 }

OpenDDS::DCPS::FilterEvaluator::FilterEvaluator ( const FilterEvaluator &   )  [private]

Member Function Documentation

bool OpenDDS::DCPS::FilterEvaluator::eval ( ACE_Message_Block *  serializedSample,
bool  swap_bytes,
bool  cdr_encap,
const MetaStruct &  meta,
const DDS::StringSeq &  params 
) const [inline]

Definition at line 98 of file FilterEvaluator.h.

00101   {
00102     SerializedForEval data(serializedSample, meta, params,
00103                            swap_bytes, cdr_encap);
00104     return eval_i(data);
00105   }

template<typename T>
bool OpenDDS::DCPS::FilterEvaluator::eval ( const T &  sample,
const DDS::StringSeq &  params 
) const [inline]

Definition at line 92 of file FilterEvaluator.h.

Referenced by OpenDDS::DCPS::DataReaderImpl_T< MessageType >::contains_sample_filtered(), and OpenDDS::DCPS::DataWriterImpl::filter_out().

00093   {
00094     DeserializedForEval data(&sample, getMetaStruct<T>(), params);
00095     return eval_i(data);
00096   }

bool OpenDDS::DCPS::FilterEvaluator::eval_i ( DataForEval &  data  )  const [private]

Definition at line 497 of file FilterEvaluator.cpp.

References OpenDDS::DCPS::Value::b_, OpenDDS::DCPS::FilterEvaluator::EvalNode::eval(), and filter_root_.

00498 {
00499   return filter_root_->eval(data).b_;
00500 }

bool OpenDDS::DCPS::FilterEvaluator::hasFilter (  )  const

Definition at line 509 of file FilterEvaluator.cpp.

References filter_root_.

Referenced by OpenDDS::DCPS::QueryConditionImpl::hasFilter().

00510 {
00511   return filter_root_ != 0;
00512 }

OpenDDS::DCPS::FilterEvaluator::OPENDDS_VECTOR ( OPENDDS_STRING   )  [private]

OpenDDS::DCPS::FilterEvaluator::OPENDDS_VECTOR ( OPENDDS_STRING   )  const

FilterEvaluator& OpenDDS::DCPS::FilterEvaluator::operator= ( const FilterEvaluator &   )  [private]

bool OpenDDS::DCPS::FilterEvaluator::usesExtendedGrammar (  )  const [inline]

Definition at line 89 of file FilterEvaluator.h.

00089 { return extended_grammar_; }

FilterEvaluator::EvalNode * OpenDDS::DCPS::FilterEvaluator::walkAst ( const AstNodeWrapper &  node  )  [private]

Definition at line 430 of file FilterEvaluator.cpp.

References OpenDDS::DCPS::arity(), OpenDDS::DCPS::child(), extended_grammar_, OpenDDS::DCPS::FilterEvaluator::Operand::isParameter(), and walkOperand().

Referenced by FilterEvaluator().

00431 {
00432   if (node->TypeMatches<CompPredDef>()) {
00433     Operand* left = walkOperand(child(node, 0));
00434     const FilterEvaluator::AstNodeWrapper& op = child(node, 1);
00435     Operand* right = walkOperand(child(node, 2));
00436     if (left->isParameter() && right->isParameter()) {
00437       extended_grammar_ = true;
00438     }
00439     return new Comparison(op, left, right);
00440   } else if (node->TypeMatches<BetweenPredDef>()) {
00441     Operand* field = walkOperand(child(node, 0));
00442     const FilterEvaluator::AstNodeWrapper& op = child(node, 1);
00443     Operand* low = walkOperand(child(node, 2));
00444     Operand* high = walkOperand(child(node, 3));
00445     return new Between(field, op, low, high);
00446   } else if (node->TypeMatches<CondDef>() || node->TypeMatches<Cond>()) {
00447     size_t a = arity(node);
00448     if (a == 1) {
00449       return walkAst(child(node, 0));
00450     } else if (a == 2) {
00451       assert(child(node, 0)->TypeMatches<NOT>());
00452       return new Logical(walkAst(child(node, 1)));
00453     } else if (a == 3) {
00454       EvalNode* left = walkAst(child(node, 0));
00455       const FilterEvaluator::AstNodeWrapper& op = child(node, 1);
00456       EvalNode* right = walkAst(child(node, 2));
00457       return new Logical(op, left, right);
00458     }
00459   }
00460 
00461   assert(0);
00462   return 0;
00463 }

FilterEvaluator::Operand * OpenDDS::DCPS::FilterEvaluator::walkOperand ( const AstNodeWrapper &  node  )  [private]

Definition at line 466 of file FilterEvaluator.cpp.

References OpenDDS::DCPS::arity(), OpenDDS::DCPS::child(), extended_grammar_, and OpenDDS::DCPS::toString().

Referenced by walkAst().

00467 {
00468   if (node->TypeMatches<FieldName>()) {
00469     return new FieldLookup(node);
00470   } else if (node->TypeMatches<IntVal>()) {
00471     return new LiteralInt(node);
00472   } else if (node->TypeMatches<CharVal>()) {
00473     return new LiteralChar(node);
00474   } else if (node->TypeMatches<FloatVal>()) {
00475     return new LiteralFloat(node);
00476   } else if (node->TypeMatches<StrVal>()) {
00477     return new LiteralString(node);
00478   } else if (node->TypeMatches<ParamVal>()) {
00479     return new Parameter(node);
00480   } else if (node->TypeMatches<CallDef>()) {
00481     if (arity(node) == 1) {
00482       return walkOperand(child(node, 0));
00483     } else {
00484       extended_grammar_ = true;
00485       Call* call = new Call(toString(child(node, 0)));
00486       for (AstNode* iter = child(node, 1); iter != 0; iter = iter->GetSibling()) {
00487         call->addChild(walkOperand(iter));
00488       }
00489       return call;
00490     }
00491   }
00492   assert(0);
00493   return 0;
00494 }

Member Data Documentation

bool OpenDDS::DCPS::FilterEvaluator::extended_grammar_ [private]

Definition at line 150 of file FilterEvaluator.h.

Referenced by walkAst(), and walkOperand().

EvalNode* OpenDDS::DCPS::FilterEvaluator::filter_root_ [private]

Definition at line 151 of file FilterEvaluator.h.

Referenced by eval_i(), FilterEvaluator(), hasFilter(), and ~FilterEvaluator().

The documentation for this class was generated from the following files:
Generated on Fri Feb 12 20:06:17 2016 for OpenDDS by  doxygen 1.4.7