dunedaq::oks::OksQueryExpression Class Reference

OKS query expression class. More...

#include <query.hpp>

Inheritance diagram for dunedaq::oks::OksQueryExpression:

Public Member Functions
virtual	~OksQueryExpression ()
OksQuery::QueryType	type () const
bool	CheckSyntax () const
bool	operator== (const class OksQueryExpression &e) const

Protected Member Functions
	OksQueryExpression (OksQuery::QueryType qet=OksQuery::unknown_type)

Private Attributes
const OksQuery::QueryType	p_type

Friends
std::ostream &	operator<< (std::ostream &s, const OksQueryExpression &qe)

Detailed Description

OKS query expression class.

The abstract class provides interface to OKS query expression. A query expression has type and method to check its correctness.

Definition at line 112 of file query.hpp.

Constructor & Destructor Documentation

~OksQueryExpression()

virtual dunedaq::oks::OksQueryExpression::~OksQueryExpression ( )

inlinevirtual

Definition at line 117 of file query.hpp.

{;}

OksQueryExpression()

dunedaq::oks::OksQueryExpression::OksQueryExpression ( OksQuery::QueryType qet = OksQuery::unknown_type )

inlineprotected

Definition at line 126 of file query.hpp.

: p_type (qet) {};

Member Function Documentation

CheckSyntax()

bool dunedaq::oks::OksQueryExpression::CheckSyntax

(

)

const

Definition at line 548 of file query.cpp.

{
  const char * fname = "OksQueryExpression::CheckSyntax()";
 
  switch(p_type) {
    case OksQuery::comparator_type:
      if(!((OksComparator *)this)->attribute && !((OksComparator *)this)->value) {
        Oks::error_msg(fname)
          << "OksComparator: Can't execute query for nil attribute or nil object-id\n";
        return false;
      }
      else if(!((OksComparator *)this)->m_comp_f) {
        Oks::error_msg(fname)
          << "OksComparator: Can't execute query for nil compare function\n";
        return false;
      }
 
      return true;
 
    case OksQuery::relationship_type:
      if(!((OksRelationshipExpression *)this)->relationship) {
        Oks::error_msg(fname)
          << "OksRelationshipExpression: Can't execute query for nil relationship\n";
        return false;
      }
      else if(!((OksRelationshipExpression *)this)->p_expression) {
        Oks::error_msg(fname)
          << "OksRelationshipExpression: Can't execute query for nil query expression\n";
        return false;
      }
      else
        return (((OksRelationshipExpression *)this)->p_expression)->CheckSyntax();
 
    case OksQuery::not_type:
      if(!((OksNotExpression *)this)->p_expression) {
        Oks::error_msg(fname)
          << "OksNotExpression: Can't execute \'not\' for nil query expression\n";
        return false;
      }
      
      return (((OksNotExpression *)this)->p_expression)->CheckSyntax();
 
    case OksQuery::and_type:
      if(((OksAndExpression *)this)->p_expressions.size() < 2) {
        Oks::error_msg(fname)
          << "OksAndExpression: Can't execute \'and\' for "
          << ((OksAndExpression *)this)->p_expressions.size() << " argument\n"
             "Two or more arguments are required\n";
        return false;
      }
      else {
        std::list<OksQueryExpression *> & elist = ((OksAndExpression *)this)->p_expressions;
        
        for(std::list<OksQueryExpression *>::iterator i = elist.begin(); i != elist.end(); ++i)
          if((*i)->CheckSyntax() == false) return false;
        
        return true;
      }
 
    case OksQuery::or_type:
      if(((OksOrExpression *)this)->p_expressions.size() < 2) {
        Oks::error_msg(fname)
          << "OksOrExpression: Can't execute \'or\' for "
          << ((OksOrExpression *)this)->p_expressions.size() << " argument\n"
             "Two or more arguments are required\n";
    
        return false;
      }
      else {
        std::list<OksQueryExpression *> & elist = ((OksOrExpression *)this)->p_expressions;
 
        for(std::list<OksQueryExpression *>::iterator i = elist.begin(); i != elist.end(); ++i)
          if((*i)->CheckSyntax() == false) return false;
        
        return true;
      }
    
    default:
      Oks::error_msg(fname)
        << "Unexpected query type " << (int)p_type << std::endl;
 
      return false;
  }
}

operator==()

bool dunedaq::oks::OksQueryExpression::operator== ( const class OksQueryExpression & e ) const

inline

Definition at line 121 of file query.hpp.

{return (this == &e);}

type()

OksQuery::QueryType dunedaq::oks::OksQueryExpression::type ( ) const

inline

Definition at line 119 of file query.hpp.

{return p_type;}

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & s, const OksQueryExpression & qe )

friend

Definition at line 783 of file query.cpp.

{
  s << '(';
  
  switch(qe.type()) {
    case OksQuery::comparator_type: {
      OksComparator *cmpr = (OksComparator *)&qe;
      const OksAttribute *a = cmpr->GetAttribute();
      OksData *v = cmpr->GetValue();
      OksQuery::Comparator f = cmpr->GetFunction();
 
      if(a) {
        s << '\"' << a->get_name() << "\" ";
      }
      else if(v) {
        s << OksQuery::OID << ' ';
      }
      else {
        s << "(null) ";
      }
 
      if(v) {
        s << *v << ' ';
      }
      else {
        s << "(null) ";
      }
 
      if(f) {
        if(f == OksQuery::equal_cmp) s << OksQuery::EQ;
        else if(f == OksQuery::not_equal_cmp) s << OksQuery::NE;
        else if(f == OksQuery::reg_exp_cmp) s << OksQuery::RE;
        else if(f == OksQuery::less_or_equal_cmp) s << OksQuery::LE;
        else if(f == OksQuery::greater_or_equal_cmp) s << OksQuery::GE;
        else if(f == OksQuery::less_cmp) s << OksQuery::LS;
        else if(f == OksQuery::greater_cmp) s << OksQuery::GT;
      }
      else
        s << "(null)";
 
      break; }
 
    case OksQuery::relationship_type: {
      OksRelationshipExpression *re = (OksRelationshipExpression *)&qe;
      const OksRelationship *r = re->GetRelationship();
      bool b = re->IsCheckAllObjects();
      OksQueryExpression *rqe = re->get();
 
      if(r)
        s << '\"' << r->get_name() << "\" ";
      else
        s << "(null) ";
 
      s << (b == true ? OksQuery::ALL_SUBCLASSES : OksQuery::SOME) << ' ';
 
      if(rqe) s << *rqe;
      else s << "(null)";
 
      break; }
 
    case OksQuery::not_type:
      s << OksQuery::NOT << ' ' << *(((OksNotExpression *)&qe)->get());
 
      break;
 
    case OksQuery::and_type: {
      s << OksQuery::AND << ' ';
 
      const std::list<OksQueryExpression *> & elist = ((OksAndExpression *)&qe)->expressions();
 
      if(!elist.empty()) {
        const OksQueryExpression * last = elist.back();
 
        for(std::list<OksQueryExpression *>::const_iterator i = elist.begin(); i != elist.end(); ++i) {
          s << *(*i);
          if(*i != last) s << ' ';
        }
      }
 
      break;
    }
 
    case OksQuery::or_type: {
      s << OksQuery::OR << ' ';
 
      const std::list<OksQueryExpression *> & elist = ((OksOrExpression *)&qe)->expressions();
 
      if(!elist.empty()) {
        const OksQueryExpression * last = elist.back();
 
        for(std::list<OksQueryExpression *>::const_iterator i = elist.begin(); i != elist.end(); ++i) {
          s << *(*i);
          if(*i != last) s << ' ';
        }
      }
 
      break;
    }
 
    case OksQuery::unknown_type: {
      s << "(unknown)";
 
      break;
    }
  }
 
  s << ')';
 
  return s;
}

Member Data Documentation

p_type

const OksQuery::QueryType dunedaq::oks::OksQueryExpression::p_type

private

Definition at line 131 of file query.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/oks/include/oks/query.hpp
• /github/workspace/dunedaq/sourcecode/oks/src/query.cpp