In This Package:

Rules.h

Go to the documentation of this file.

#ifndef RULES_H
#define RULES_H

#include <string>
#include "RuleParser/Queriable.h"



namespace RuleParser{



class Rule
{
public:
  virtual ~Rule() { if(mA) delete mA; if(mB) delete mB; };  
  virtual bool select(const Queriable*) = 0;
  virtual const std::string& name() const { return m_name; };
  
protected:
    Rule( std::string name = "unnamed rule", 
          Rule* a=0,  Rule* b=0) 
          : m_name(name), mA(a), mB(b) {};
    std::string m_name;
    Rule* mA;
    Rule* mB;
};




class AnyRule : public Rule
{
public:  
  AnyRule(std::string n = "AnyRule") : Rule(n) {};
  virtual ~AnyRule() {};
  virtual bool select(const Queriable*) { return true; };
};




class NoneRule : public Rule
{
public:  
  NoneRule(std::string n = "NoneRule") : Rule(n) {};
  virtual ~NoneRule() {};
  virtual bool select(const Queriable*) { return false; };
};




class AndRule : public Rule
{
public:  
  AndRule(std::string n, 
          Rule* a, Rule* b) : Rule(n,a,b) {};
  virtual ~AndRule() {};
  virtual bool select(const Queriable* thing) { 
    if(this->mA->select(thing)) return this->mB->select(thing); 
    return false;
    };
};



class OrRule : public Rule
{
public:
  
  OrRule(std::string n, 
         Rule* a, Rule* b) : Rule(n,a,b) {};
  virtual ~OrRule() {};
  virtual bool select(const Queriable* thing) { 
    if(this->mA->select(thing)) return true; 
    return this->mB->select(thing); 
    };
};



class NotRule : public Rule
{
public:

  NotRule(std::string n,
          Rule* a) : Rule(n,a) {};
  virtual ~NotRule() {};
  virtual bool select(const Queriable* thing) { 
    return (! this->mA->select(thing) ); 
  };
};


template<typename Type>
class LT_Rule : public Rule
{
public:

  LT_Rule(std::string n,
          int whichParam,Type value) 
        : Rule(n) 
        , mParameterId(whichParam),mCut(value) {};
  virtual ~LT_Rule() {};
  virtual bool select(const Queriable* thing) {
    Type value;
    thing->queryParam(mParameterId,value); 
    if(value < mCut) return true;
    return false;
  }
protected:
  int  mParameterId;
  Type mCut;
};


template<typename Type>
class LE_Rule : public Rule
{
public:

  LE_Rule(std::string n,
          int whichParam,Type value) 
        : Rule(n) 
        , mParameterId(whichParam),mCut(value) {};
  virtual ~LE_Rule() {};
  virtual bool select(const Queriable* thing) {
    Type value;
    thing->queryParam(mParameterId,value); 
    if(value <= mCut) return true;
    return false;
  }
protected:
  int  mParameterId;
  Type mCut;
};


template<typename Type>
class GT_Rule : public Rule
{
public:

  GT_Rule(std::string n,
          int whichParam,Type value) 
        : Rule(n) 
        , mParameterId(whichParam),mCut(value) {};
  virtual ~GT_Rule() {};
  virtual bool select(const Queriable* thing) {
    Type value;
    thing->queryParam(mParameterId,value); 
    if(value > mCut) return true;
    return false;
  }
protected:
  int  mParameterId;
  Type mCut;
};


template<typename Type>
class GE_Rule : public Rule
{
public:

  GE_Rule(std::string n,
          int whichParam,Type value) 
        : Rule(n) 
        , mParameterId(whichParam),mCut(value) {};
  virtual ~GE_Rule() {};
  virtual bool select(const Queriable* thing) {
    Type value;
    thing->queryParam(mParameterId,value); 
    if(value >= mCut) return true;
    return false;
  }
protected:
  int  mParameterId;
  Type mCut;
};


template<typename Type>
class EQ_Rule : public Rule
{
public:

  EQ_Rule(std::string n,
          int whichParam,Type value) 
        : Rule(n) 
        , mParameterId(whichParam),mCut(value) {};
  virtual ~EQ_Rule() {};
  virtual bool select(const Queriable* thing) {
    Type value;
    thing->queryParam(mParameterId,value); 
    if(value == mCut) return true;
    return false;
  }
protected:
  int  mParameterId;
  Type mCut;
};


template<typename Type>
class NEQ_Rule : public Rule
{
public:

  NEQ_Rule(std::string n,
           int whichParam,Type value) 
        : Rule(n) 
        , mParameterId(whichParam),mCut(value) {};
  virtual ~NEQ_Rule() {};
  virtual bool select(const Queriable* thing) {
    Type value;
    thing->queryParam(mParameterId,value); 
    if(value != mCut) return true;
    return false;
  }
protected:
  int  mParameterId;
  Type mCut;
};

}


#endif

---