query.hpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks source for the DUNE DAQ project.
// Fork baseline commit: oks-08-03-04 (2022-04-14).
// Renamed since fork: yes (from oks/query.h to include/oks/query.hpp).

 
#ifndef __OKS_QUERY
#define __OKS_QUERY
 
#include "oks/defs.hpp"
#include "oks/object.hpp"
 
#include <exception>
#include <list>
 
#include <boost/regex.hpp>
 
namespace dunedaq {
namespace oks {
 
class OksQueryExpression;


 
class OksQuery
{
public:
  OksQuery(bool b, OksQueryExpression* q = 0)
    : p_sub_classes(b)
    , p_expression(q)
    , p_status(0) {};
  OksQuery(const OksClass*, const std::string&);
  virtual ~OksQuery();
 
  friend std::ostream& operator<<(std::ostream&, const OksQuery&);
 
  bool search_in_subclasses() const { return p_sub_classes; }
  void search_in_subclasses(bool b) { p_sub_classes = b; }
 
  OksQueryExpression* get() const { return p_expression; }
  void set(OksQueryExpression* q) { p_expression = q; }
 
  bool good() const { return (p_status == 0); }
 
  enum QueryType
  {
    unknown_type,
    comparator_type,
    relationship_type,
    not_type,
    and_type,
    or_type
  };
 
  static const char* OR;
  static const char* AND;
  static const char* NOT;
  static const char* SOME;
  static const char* THIS_CLASS;
  static const char* ALL_SUBCLASSES;
  static const char* OID;
  static const char* EQ;
  static const char* NE;
  static const char* RE;
  static const char* LE;
  static const char* GE;
  static const char* LS;
  static const char* GT;
  static const char* PATH_TO;
  static const char* DIRECT;
  static const char* NESTED;
 
  static bool equal_cmp(const OksData*, const OksData*);
  static bool not_equal_cmp(const OksData*, const OksData*);
  static bool less_or_equal_cmp(const OksData*, const OksData*);
  static bool greater_or_equal_cmp(const OksData*, const OksData*);
  static bool less_cmp(const OksData*, const OksData*);
  static bool greater_cmp(const OksData*, const OksData*);
  static bool reg_exp_cmp(const OksData*, const OksData* regexp);
 
  typedef bool (*Comparator)(const OksData*, const OksData*);
 
private:
  bool p_sub_classes;
  OksQueryExpression* p_expression;
  int p_status;
 
  static OksQueryExpression* create_expression(const OksClass*, const std::string&);
};


 
class OksQueryExpression
{
  friend std::ostream& operator<<(std::ostream&, const OksQueryExpression&);
 
public:
  virtual ~OksQueryExpression() { ; }
 
  OksQuery::QueryType type() const { return p_type; }
  bool CheckSyntax() const;
  bool operator==(const class OksQueryExpression& e) const { return (this == &e); }
 
protected:
  OksQueryExpression(OksQuery::QueryType qet = OksQuery::unknown_type)
    : p_type(qet) {};
 
private:
  const OksQuery::QueryType p_type;
};


 
class OksComparator : public OksQueryExpression
{
  friend class OksObject;
  friend class OksQueryExpression;
 
public:
  OksComparator(const OksAttribute* a, OksData* v, OksQuery::Comparator f)
    : OksQueryExpression(OksQuery::comparator_type)
    , attribute(a)
    , value(v)
    , m_comp_f(f)
    , m_reg_exp(0) {};
 
  virtual ~OksComparator()
  {
    delete value;
    if (m_reg_exp)
      delete m_reg_exp;
  }
 
  const OksAttribute* GetAttribute() const { return attribute; }
  void SetAttribute(const OksAttribute* a) { attribute = a; }
 
  OksData* GetValue() { return value; }
  void SetValue(OksData* v);
 
  void clean_reg_exp();
 
  OksQuery::Comparator GetFunction() const { return m_comp_f; }
  void SetFunction(OksQuery::Comparator f) { m_comp_f = f; }
 
private:
  const OksAttribute* attribute;
  OksData* value;
  OksQuery::Comparator m_comp_f;
  boost::regex* m_reg_exp;
};


 
class OksRelationshipExpression : public OksQueryExpression
{
  friend class OksObject;
  friend class OksQueryExpression;
 
public:
  OksRelationshipExpression(const OksRelationship* r, OksQueryExpression* q, bool b = false)
    : OksQueryExpression(OksQuery::relationship_type)
    , relationship(r)
    , checkAllObjects(b)
    , p_expression(q) {};
 
  virtual ~OksRelationshipExpression() { delete p_expression; }
 
  const OksRelationship* GetRelationship() const { return relationship; }
  void SetRelationship(const OksRelationship* r) { relationship = r; }
 
  OksQueryExpression* get() const { return p_expression; }
  void set(OksQueryExpression* q) { p_expression = q; }
 
  bool IsCheckAllObjects() const { return checkAllObjects; }
  void SetIsCheckAllObjects(const bool b) { checkAllObjects = b; }
 
private:
  const OksRelationship* relationship;
  bool checkAllObjects;
  OksQueryExpression* p_expression;
};


 
class OksNotExpression : public OksQueryExpression
{
 
  friend class OksObject;
  friend class OksQueryExpression;
 
public:
  OksNotExpression(OksQueryExpression* q = 0)
    : OksQueryExpression(OksQuery::not_type)
    , p_expression(q) {};
 
  virtual ~OksNotExpression() { delete p_expression; }
 
  OksQueryExpression* get() const { return p_expression; }
  void set(OksQueryExpression* q) { p_expression = q; }
 
private:
  OksQueryExpression* p_expression;
};

 
class OksListBaseQueryExpression
{
 
  friend class OksObject;
  friend class OksClass;
  friend class OksQueryExpression;
 
public:
  virtual ~OksListBaseQueryExpression()
  {
    while (!p_expressions.empty()) {
      OksQueryExpression* qe = p_expressions.front();
      p_expressions.pop_front();
      delete qe;
    }
  }
 
  const std::list<OksQueryExpression*>& expressions() const { return p_expressions; }
  void add(OksQueryExpression* q) { p_expressions.push_back(q); }
 
protected:
  OksListBaseQueryExpression() {};
 
private:
  std::list<OksQueryExpression*> p_expressions;
};

 
class OksAndExpression
  : public OksQueryExpression
  , public OksListBaseQueryExpression
{
public:
  OksAndExpression()
    : OksQueryExpression(OksQuery::and_type) {};
 
  virtual ~OksAndExpression() { ; }
};

 
class OksOrExpression
  : public OksQueryExpression
  , public OksListBaseQueryExpression
{
public:
  OksOrExpression()
    : OksQueryExpression(OksQuery::or_type) {};
 
  virtual ~OksOrExpression() { ; }
};
 
inline OksQuery::~OksQuery()
{
  delete p_expression;
}

 
class bad_query_syntax : public std::exception
{
 
  std::string p_what;
 
public:
  bad_query_syntax(const std::string& what_arg) noexcept
    : p_what(what_arg)
  {
  }
  virtual ~bad_query_syntax() noexcept {}
 
  virtual const char* what() const noexcept { return p_what.c_str(); }
};

 
class QueryPathExpression
{
 
  friend class QueryPath;
  friend class OksObject;
 
public:
  bool get_use_nested_lookup() const { return p_use_nested_lookup; }
  const std::list<std::string>& get_rel_names() const { return p_rel_names; }
  const QueryPathExpression* get_next() const { return p_next; }
 
protected:
  QueryPathExpression(bool v)
    : p_use_nested_lookup(v)
  {
  }
  QueryPathExpression(const std::string& expression);
 
  ~QueryPathExpression() { delete p_next; }
 
  bool p_use_nested_lookup;
  std::list<std::string> p_rel_names;
  QueryPathExpression* p_next;
};

 
class QueryPath
{
 
public:
  QueryPath(const OksObject* o, QueryPathExpression* qpe)
    : p_goal(o)
    , p_start(qpe)
  {
  }
  QueryPath(const std::string& query, const OksKernel&);
  ~QueryPath() { delete p_start; }
 
  const QueryPathExpression* get_start_expression() const { return p_start; }
  const OksObject* get_goal_object() const { return p_goal; }
 
private:
  const OksObject* p_goal;
  QueryPathExpression* p_start;
};
 
std::ostream&
operator<<(std::ostream&, const oks::QueryPathExpression&);
std::ostream&
operator<<(std::ostream&, const oks::QueryPath&);
 
} // namespace oks
} // namespace dunedaq
#endif