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 111 of file query.hpp.

Constructor & Destructor Documentation

~OksQueryExpression()

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

inlinevirtual

Definition at line 116 of file query.hpp.

{ ; }

OksQueryExpression()

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

inlineprotected

Definition at line 123 of file query.hpp.

    : p_type(qet) {};

Member Function Documentation

CheckSyntax()

bool dunedaq::oks::OksQueryExpression::CheckSyntax

(

)

const

Definition at line 542 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 120 of file query.hpp.

{ return (this == &e); }

type()

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

inline

Definition at line 118 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 760 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 127 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