/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Calibration/rdbModel/rdbModel-00-01-01/rdbModel/Tables/Assertion.h

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/rdbModel/rdbModel/Tables/Assertion.h,v 1.1.1.1 2005/10/17 06:10:53 maqm Exp $
#ifndef RDBMODEL_ASSERTION_H
#define RDBMODEL_ASSERTION_H
#include <vector>
#include <string>
#include "rdbModel/Rdb.h"
#include "rdbModel/Management/Visitor.h"
#include "rdbModel/Tables/Column.h"

namespace rdbModel{

  class Table;

    enum OPTYPE {
      OPTYPEundefined = 0,
      OPTYPEor = 1,
      OPTYPEand,
      OPTYPEnot,
      OPTYPEexists,
      OPTYPEisNull,
      OPTYPEisEmpty,
      OPTYPEequal,           // first of 2-operand compare ops
      OPTYPEnotEqual,
      OPTYPElessThan,
      OPTYPEgreaterThan,
      OPTYPElessOrEqual,
      OPTYPEgreaterOrEqual,
      OPTYPElast
    };


  class Assertion {
  public:
    class Operator;         // nested class declared below

  public:
    // when does this assertion get applied?
    /*
    enum WHEN {
      WHENundefined = 0,
      WHENglobalCheck = 1,
      WHENchangeRow,
      WHENwhere     // as a WHERE clause, used and then discarded
    };
    */

    class Operator {
    public:
      Operator() : m_opType(OPTYPEundefined) {};
      ~Operator();

      Operator(OPTYPE type, const std::string& leftArg, 
               const std::string& rightArg, 
               FIELDTYPE leftType, FIELDTYPE rightType);

      Operator(OPTYPE type, const std::string& tableName, Operator* child=0);

      Operator(OPTYPE type, const std::vector<Operator*>& children,
               bool keepChildren = false);

      Operator(Operator* op, Row* toBe);

      bool appendChild(Operator* child);

      bool validCompareOp(Table* table) const;

      bool isCompareOp() const {return (m_opType >= OPTYPEisNull);}

      const std::string* getCompareArgs() const;

      const std::string& getTableName() const;

      const FIELDTYPE* getCompareArgTypes() const;

      const std::vector<Operator* >& getChildren() const;

      OPTYPE getOpType() const {return m_opType;}

      bool getToBe() const {return m_toBe;}

      bool getOld() const {return m_old;}

      bool verify(Row& old, Row& toBe, Table* t) const;



    private:
      bool verifyCompare(Row& old, Row& toBe, Table* t) const;

      bool compareTs(const std::string* vals, OPTYPE type) const;

      bool compareInt(const std::string* vals, OPTYPE type) const;

      bool compareFloat(const std::string* vals, OPTYPE type) const;

      bool compareString(const std::string* vals, OPTYPE type) const;

      OPTYPE m_opType;

      std::string m_compareArgs[2];
      FIELDTYPE m_compareType[2]; 

      std::string m_tableName;

      bool        m_keepChildren;

      std::vector<Operator* > m_operands;  // #allowed depends on opType

      bool  m_toBe; 

      bool  m_old;
    };

    Assertion(Operator* op = 0, Table* myTable=0, bool keepOp=false) : 
      m_op(op), m_myTable(myTable), m_keepOp(keepOp)
    { m_compiled.clear(); m_name.clear();};

    Assertion(const Assertion* orig, Row* toBe);

    ~Assertion();
    //    WHEN getWhen() const {return m_when;}
    Visitor::VisitorState accept(Visitor* v);

    Operator* getOperator() const {return m_op;}
    const std::string& getPrecompiled() const {return m_compiled;}
    
    bool getToBe() const {return m_op->getToBe();}

    bool getOld() const {return m_op->getOld();}

    const std::string& getName() const {return m_name;}
    void setName(const std::string& name) {m_name = name;}

    bool verify(Row& old, Row& toBe) const;

  private:
    Operator* m_op;
    Table* m_myTable;
    bool   m_keepOp;
    std::string m_name;

    std::string m_compiled;  

  };
}
#endif

---