rdbModel::Assertion::Operator Class Reference

#include <Assertion.h>

Public Member Functions
	Operator ()
	~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)
	Constructor for EXISTS.
	Operator (OPTYPE type, const std::vector< Operator * > &children, bool keepChildren=false)
	Constructor for OR, AND, NOT.
	Operator (Operator *op, Row *toBe)
	Copy an operator, substituting from toBe row as appropriate.
bool	appendChild (Operator *child)
	Add another child to a conjunction-style operator.
bool	validCompareOp (Table *table) const
bool	isCompareOp () const
const std::string *	getCompareArgs () const
	Throw exception if Operator is not a comparison operator.
const std::string &	getTableName () const
	Throw exception if Operaotr is not EXISTS.
const FIELDTYPE *	getCompareArgTypes () const
	Get types of comparison args.
const std::vector< Operator * > &	getChildren () const
	Throw exception if Operator is a comparison operator.
OPTYPE	getOpType () const
bool	getToBe () const
	True if operator or sub-operator refers to future row.
bool	getOld () const
	True if operator or sub-operator refers to existing row.
bool	verify (Row &old, Row &toBe, Table *t) const
	Evaluate operator on argument Rows.

Detailed Description

Definition at line 71 of file Calibration/rdbModel/rdbModel-00-01-01/rdbModel/Tables/Assertion.h.

Constructor & Destructor Documentation

Operator() [1/5]

rdbModel::Assertion::Operator::Operator ( )

inline

Definition at line 73 of file Calibration/rdbModel/rdbModel-00-01-01/rdbModel/Tables/Assertion.h.

: m_opType(OPTYPEundefined) {};

Referenced by Operator().

~Operator()

rdbModel::Assertion::Operator::~Operator

(

)

Definition at line 12 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                               {
    if (!m_keepChildren) {
      while (m_operands.size() ) {
        Operator* op = m_operands.back();
        m_operands.pop_back();
        delete op;
      }
    }
  }

Operator() [2/5]

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

Constructor for comparison. If the operator is OPTTYPEisNull or OPTYPEisEmpty rightArg and rightLiteral are ignored.

Definition at line 39 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

    :  m_opType(type), m_keepChildren(false), m_toBe(false), m_old(false) {
 
    m_tableName.clear();
    m_operands.clear();
    if (!isCompareOp()) {
      m_opType = OPTYPEundefined;
      return;
    }
 
    m_compareArgs[0] = leftArg;
    m_compareArgs[1] = rightArg;
    m_compareType[0] = leftLiteral;
    m_compareType[1] = rightLiteral;
    if ((type == OPTYPEisNull) || (type ==OPTYPEisEmpty)) {
      m_compareType[1] = FIELDTYPElit;
      m_compareArgs[1] = "";
    }
    m_toBe = ((leftLiteral == FIELDTYPEtoBe) || 
              (rightLiteral == FIELDTYPEtoBe));
    m_old = ((leftLiteral == FIELDTYPEold) || 
             (rightLiteral == FIELDTYPEold));
  }

Operator() [3/5]

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

Constructor for EXISTS.

Definition at line 67 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                                                 : m_opType(type),
                                                   m_tableName(tableName),
                                                   m_keepChildren(false)
  {
    if (type != OPTYPEexists) {
      m_opType = OPTYPEundefined;
      return;
    }
    m_operands.clear();
    m_operands.push_back(child);
  }

Operator() [4/5]

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

Constructor for OR, AND, NOT.

Definition at line 81 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                                                    :
    m_opType(type), m_keepChildren(keepChildren) {
 
    m_toBe = false;
    m_old = false;
    if ((type == OPTYPEor) || (type == OPTYPEand) || (type = OPTYPEnot)) {
      m_tableName.clear();
      unsigned int nChild = children.size();
      if (!nChild) {
        m_opType = OPTYPEundefined;
        return;
      }
      for (unsigned int iChild = 0; iChild < nChild; iChild++) {
        m_toBe |= (children[iChild]->m_toBe);
        m_old |= (children[iChild]->m_old);
        m_operands.push_back(children[iChild]);
      }
    }
    else m_opType = OPTYPEundefined;
  }

Operator() [5/5]

rdbModel::Assertion::Operator::Operator	(	Operator *	op,
		Row *	toBe
	)

Copy an operator, substituting from toBe row as appropriate.

Definition at line 106 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

    : m_opType(op->m_opType), m_tableName(op->m_tableName), 
      m_keepChildren(false), m_toBe(false), m_old(op->m_old) {
    m_operands.clear();
 
    switch (m_opType) {
      // OPTYPEor, and, not and exists all have child operators
    case OPTYPEor:
    case OPTYPEand: 
    case OPTYPEnot: 
    case OPTYPEexists:
      {
        unsigned nChild = op->m_operands.size();
        for (unsigned iChild = 0; iChild < nChild; iChild++) {
          Operator* child = new Operator((op->m_operands)[iChild], toBe);
          appendChild(child);
        }
        break;
      }
    case OPTYPEequal:
    case OPTYPEnotEqual:
    case OPTYPElessThan:
    case OPTYPEgreaterThan:
    case OPTYPElessOrEqual:
    case OPTYPEgreaterOrEqual:
    case OPTYPEisEmpty:
    case OPTYPEisNull: {
      for (unsigned i = 0; i < 2; i++) {
        if ((op->m_compareType[i] == FIELDTYPEtoBe) || 
            (op->m_compareType[i] == FIELDTYPEtoBeDef) ) { 
          // have to supply value from row
          FieldVal* f = toBe->find(op->m_compareArgs[i]);
          if (!f) {
            throw RdbException
              ("Assertion::Operator constructor can't resolve field");
          }
          m_compareArgs[i] = f->m_val;
          m_compareType[i] = FIELDTYPElit;
        }
        else {   // just copy what's there
          m_compareArgs[i] = op->m_compareArgs[i];
          m_compareType[i] =op->m_compareType[i];
        }
      }
      break;
    }
    default:
      throw RdbException("Assertion::Operator constructor - Unknown OP type");
    }
  }

Member Function Documentation

appendChild()

bool rdbModel::Assertion::Operator::appendChild

(

Operator *

child

)

Add another child to a conjunction-style operator.

Definition at line 158 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                                                     {
    m_toBe |= child->m_toBe;
    m_old |= child->m_old;
    if  ((m_opType == OPTYPEor) || (m_opType == OPTYPEand) ) {
      m_operands.push_back(child);
      return true;
    }
    else if ((m_opType == OPTYPEnot) && (m_operands.size() == 0) ) {
      m_operands.push_back(child);
      return true;
    }
    throw RdbException("Assertion::Operator::appendChild: wrong parent operator type");
    return false;
  }

Referenced by Operator().

getChildren()

const std::vector< Assertion::Operator * > & rdbModel::Assertion::Operator::getChildren

(

)

const

Throw exception if Operator is a comparison operator.

Definition at line 338 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                                       {
    if (isCompareOp()) 
      throw RdbException("Assertion::Operator::getChildren: wrong type");
    return m_operands;
  }

getCompareArgs()

const std::string * rdbModel::Assertion::Operator::getCompareArgs

(

)

const

Throw exception if Operator is not a comparison operator.

Definition at line 193 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                                                           {
    if (!isCompareOp()) 
      throw RdbException("Assertion::Operator::getCompareArgs: wrong type");
    return &m_compareArgs[0];
  }

getCompareArgTypes()

const FIELDTYPE * rdbModel::Assertion::Operator::getCompareArgTypes

(

)

const

Get types of comparison args.

Throw exception if Operator is not a comparison operator.

Definition at line 201 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                                                               {
    if (!isCompareOp()) 
      throw RdbException("Assertion::Operator::getLiteralness: wrong type");
    return &m_compareType[0];
  }

getOld()

bool rdbModel::Assertion::Operator::getOld ( ) const

inline

True if operator or sub-operator refers to existing row.

Definition at line 121 of file Calibration/rdbModel/rdbModel-00-01-01/rdbModel/Tables/Assertion.h.

{return m_old;}

Referenced by rdbModel::Assertion::getOld().

getOpType()

OPTYPE rdbModel::Assertion::Operator::getOpType ( ) const

inline

Definition at line 115 of file Calibration/rdbModel/rdbModel-00-01-01/rdbModel/Tables/Assertion.h.

{return m_opType;}

getTableName()

const std::string & rdbModel::Assertion::Operator::getTableName

(

)

const

Throw exception if Operaotr is not EXISTS.

Throw exception if Operator is not EXISTS.

Definition at line 208 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                                                         {
    if (m_opType != OPTYPEexists) 
      throw RdbException("Assertion::Operator::getTableName: wrong type");
    return m_tableName;
  }

getToBe()

bool rdbModel::Assertion::Operator::getToBe ( ) const

inline

True if operator or sub-operator refers to future row.

Definition at line 118 of file Calibration/rdbModel/rdbModel-00-01-01/rdbModel/Tables/Assertion.h.

{return m_toBe;}

Referenced by rdbModel::Assertion::getToBe().

isCompareOp()

bool rdbModel::Assertion::Operator::isCompareOp ( ) const

inline

True if operator is isNull, isEmpty or any of the usual arithmetic comparisons

Definition at line 101 of file Calibration/rdbModel/rdbModel-00-01-01/rdbModel/Tables/Assertion.h.

{return (m_opType >= OPTYPEisNull);}

Referenced by Operator().

validCompareOp()

bool rdbModel::Assertion::Operator::validCompareOp

(

Table *

table

)

const

Check whether columns or column and literal to be compared have compatible types

Definition at line 174 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                                                             {
    if (m_compareType[0] != FIELDTYPElit) {
      Column* col0 = myTable->getColumnByName(m_compareArgs[0]);
      if (m_compareType[1] != FIELDTYPElit) {
        Column* col1 = myTable->getColumnByName(m_compareArgs[1]);
        return col1->isCompatible(col0);
      }
      else {  // one column, one literal
        return col0->okValue(m_compareArgs[1], false);
      }
    }
    else { // 1st arg is a literal; second arg must be column
      Column* col1 = myTable->getColumnByName(m_compareArgs[1]);
      return col1->okValue(m_compareArgs[0], false);        
    }
  }

verify()

bool rdbModel::Assertion::Operator::verify	(	Row &	old,
		Row &	toBe,
		Table *	t
	)		const

Evaluate operator on argument Rows.

Definition at line 215 of file Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx.

                                                                     {
    switch(m_opType) {
    case OPTYPEor: {
      unsigned nChild = m_operands.size();
      for (unsigned i = 0; i < nChild; i++) {
        if (m_operands[i]->verify(old, toBe, t)) return true;
      }
      return false;
    }
 
    case OPTYPEand: {
      unsigned nChild = m_operands.size();
      for (unsigned i = 0; i < nChild; i++) {
        if (!(m_operands[i]->verify(old, toBe, t))) return false;
      }
      return true;
    }
    case OPTYPEnot:
      return (!(m_operands[0]->verify(old, toBe, t)));
 
      
    case OPTYPEisNull: 
    case OPTYPEisEmpty: 
      // These two are almost the same
      {
      Row* r = 0;
      if ( (m_compareType[0] == FIELDTYPEtoBe) || 
           (m_compareType[0] == FIELDTYPEtoBeDef) ) r = &toBe;
      else r = &old;
 
      FieldVal* f = r->find(m_compareArgs[0]);
      if (f) {
        if (m_opType == OPTYPEisNull) return f->m_null;
        return ((f->m_val).size() == 0);
      }
      else {  // improper input.  Field should have been found
        throw RdbException("Assertion::Operator::verify missing isNull field");
      }
    }
      // handle all 2-argument compare operators together
    case OPTYPEequal:
    case OPTYPEnotEqual:
    case OPTYPElessThan:
    case OPTYPEgreaterThan:
    case OPTYPElessOrEqual:
    case OPTYPEgreaterOrEqual:
      return verifyCompare(old, toBe, t);
 
    default:
      return false;
    }
    return false;
  }

Referenced by rdbModel::Assertion::verify().

---

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

• Calibration/rdbModel/rdbModel-00-01-01/rdbModel/Tables/Assertion.h
• Calibration/rdbModel/rdbModel-00-01-01/src/Tables/Assertion.cxx