#include <CEvaluationNodeLogical.h>

Inheritance diagram for CEvaluationNodeLogical:

Collaboration diagram for CEvaluationNodeLogical:

Public Types
enum	SubType { INVALID = 0x00FFFFFF, OR = 0x00000001, XOR = 0x00000002, AND = 0x00000003, EQ = 0x00000004, NE = 0x00000005, GT = 0x00000006, GE = 0x00000007, LT = 0x00000008, LE = 0x00000009 }

Public Types inherited from CEvaluationNode
enum	Type { INVALID = 0xFF000000, NUMBER = 0x01000000, CONSTANT = 0x02000000, OPERATOR = 0x03000000, OBJECT = 0x04000000, FUNCTION = 0x05000000, CALL = 0x06000000, STRUCTURE = 0x07000000, CHOICE = 0x08000000, VARIABLE = 0x09000000, WHITESPACE = 0x0a000000, LOGICAL = 0x0b000000, MV_FUNCTION = 0x0c000000, VECTOR = 0x0d000000, DELAY = 0x0e000000 }

Public Types inherited from CCopasiNode< std::string >
typedef std::string	Data

Public Member Functions
virtual void	calculate ()

	CEvaluationNodeLogical (const SubType &subType, const Data &data)

	CEvaluationNodeLogical (const CEvaluationNodeLogical &src)

virtual bool	compile (const CEvaluationTree *pTree)

virtual std::string	getBerkeleyMadonnaString (const std::vector< std::string > &children) const

virtual std::string	getCCodeString (const std::vector< std::string > &children) const

virtual std::string	getDisplayString (const std::vector< std::string > &children) const

virtual std::string	getInfix (const std::vector< std::string > &children) const

virtual std::string	getMMLString (const std::vector< std::string > &children, bool expand, const std::vector< std::vector< std::string > > &variables) const

virtual std::string	getXPPString (const std::vector< std::string > &children) const

virtual bool	isBoolean () const

virtual ASTNode *	toAST (const CCopasiDataModel *pDataModel) const

virtual	~CEvaluationNodeLogical ()

Public Member Functions inherited from CEvaluationNode
void	addChildren (const std::vector< CEvaluationNode * > &children)

std::string	buildBerkeleyMadonnaString () const

std::string	buildCCodeString () const

std::string	buildDisplayString () const

std::string	buildInfix () const

std::string	buildMMLString (bool expand, const std::vector< std::vector< std::string > > &variables) const

std::string	buildXPPString () const

	CEvaluationNode ()

	CEvaluationNode (const CEvaluationNode &src)

CEvaluationNode *	copyBranch () const

CEvaluationNode *	copyNode (CEvaluationNode child1, CEvaluationNode child2) const

CEvaluationNode *	copyNode (const std::vector< CEvaluationNode * > &children) const

const CEvaluationNode *	findTopMinus (const std::vector< CFunctionAnalyzer::CValue > &callParameters) const

const Type &	getType () const

const C_FLOAT64 &	getValue () const

const C_FLOAT64 *	getValuePointer () const

virtual bool	operator!= (const CEvaluationNode &right) const

bool	operator< (const CEvaluationNode &right) const

bool	operator< (const CEvaluationNode &rhs)

bool	operator== (const CEvaluationNode &right) const

void	printRecursively (std::ostream &os, int indent=0) const

void	printRecursively () const

virtual CEvaluationNode *	simplifyNode (const std::vector< CEvaluationNode * > &children) const

CEvaluationNode *	splitBranch (const CEvaluationNode *splitnode, bool left) const

virtual	~CEvaluationNode ()

Public Member Functions inherited from CCopasiNode< std::string >
virtual bool	addChild (CCopasiNode< Data > pChild, CCopasiNode< Data > pAfter=NULL)

bool	addSibling (CCopasiNode< Data > pSibling, CCopasiNode< Data > pAfter=NULL)

	CCopasiNode (CCopasiNode< Data > *pParent=NULL)

	CCopasiNode (const CCopasiNode< Data > &src)

	CCopasiNode (const Data &data, CCopasiNode< Data > *pParent=NULL)

bool	deleteChildren ()

CCopasiNode< Data > *	getChild ()

const CCopasiNode< Data > *	getChild () const

CCopasiNode< Data > *	getChild (const size_t &index)

const CCopasiNode< Data > *	getChild (const size_t &index) const

virtual const Data &	getData () const

CCopasiNode< Data > *	getNext ()

const CCopasiNode< Data > *	getNext () const

CCopasiNode< Data > *	getNextNonChild ()

const CCopasiNode< Data > *	getNextNonChild () const

size_t	getNumChildren () const

CCopasiNode< Data > *	getParent ()

const CCopasiNode< Data > *	getParent () const

CCopasiNode< Data > *	getSibling ()

const CCopasiNode< Data > *	getSibling () const

virtual bool	removeChild (CCopasiNode< Data > *pChild)

virtual bool	setData (const Data &data)

virtual	~CCopasiNode ()

Static Public Member Functions
static CEvaluationNode *	fromAST (const ASTNode pASTNode, const std::vector< CEvaluationNode > &children)

Static Public Member Functions inherited from CEvaluationNode
static CEvaluationNode *	create (const Type &type, const Data &data)

static bool	isKeyword (const std::string &str)

static Type	subType (const Type &type)

static Type	type (const Type &type)

Private Member Functions
	CEvaluationNodeLogical ()

Private Attributes
CEvaluationNode *	mpLeft

CEvaluationNode *	mpRight

Additional Inherited Members
Protected Member Functions inherited from CEvaluationNode
	CEvaluationNode (const Type &type, const Data &data)

Protected Member Functions inherited from CCopasiNode< std::string >
bool	setChild (CCopasiNode< Data > *pChild)

bool	setParent (CCopasiNode< Data > *pParent)

bool	setSibling (CCopasiNode< Data > *pSibling)

Protected Attributes inherited from CEvaluationNode
class CEvaluationNode::CPrecedence	mPrecedence

const C_FLOAT64 *	mpValue

Type	mType

C_FLOAT64	mValue

Protected Attributes inherited from CCopasiNode< std::string >
Data	mData

Detailed Description

This is the class for nodes presenting opertors used in an evaluation trees.

Definition at line 32 of file CEvaluationNodeLogical.h.

Member Enumeration Documentation

enum CEvaluationNodeLogical::SubType

Enumeration of possible node types.

Enumerator
INVALID
OR
XOR
AND
EQ
NE
GT
GE
LT
LE

Definition at line 38 of file CEvaluationNodeLogical.h.

   {
     INVALID = 0x00FFFFFF,
     //      NOT = 0x00000001,
     OR = 0x00000001,
     XOR = 0x00000002,
     AND = 0x00000003,
     EQ = 0x00000004,
     NE = 0x00000005,
     GT = 0x00000006,
     GE = 0x00000007,
     LT = 0x00000008,
     LE = 0x00000009
   };

Constructor & Destructor Documentation

CEvaluationNodeLogical::CEvaluationNodeLogical ( )

private

Default constructor

Definition at line 21 of file CEvaluationNodeLogical.cpp.

Referenced by fromAST().

                                               :
   CEvaluationNode(CEvaluationNode::INVALID, ""),
   mpLeft(NULL),
   mpRight(NULL)
 {}

CEvaluationNodeLogical::CEvaluationNodeLogical	(	const SubType &	subType,
		const Data &	data
	)

Default constructor

Parameters

const	SubType & subType
const	Data & data

Definition at line 27 of file CEvaluationNodeLogical.cpp.

References AND, EQ, GE, GT, LE, LT, CEvaluationNode::mPrecedence, CEvaluationNode::mType, NE, OR, PRECEDENCE_LOGIG_AND, PRECEDENCE_LOGIG_EQ, PRECEDENCE_LOGIG_GE, PRECEDENCE_LOGIG_GT, PRECEDENCE_LOGIG_LE, PRECEDENCE_LOGIG_LT, PRECEDENCE_LOGIG_NE, PRECEDENCE_LOGIG_OR, PRECEDENCE_LOGIG_XOR, and XOR.

                       :
   CEvaluationNode((Type)(CEvaluationNode::LOGICAL | subType), data),
   mpLeft(NULL),
   mpRight(NULL)
 {
   switch (mType & 0x00FFFFFF)
     {
       case OR:
         mPrecedence = PRECEDENCE_LOGIG_OR;
         break;
 
       case XOR:
         mPrecedence = PRECEDENCE_LOGIG_XOR;
         break;
 
       case AND:
         mPrecedence = PRECEDENCE_LOGIG_AND;
         break;
 
       case EQ:
         mPrecedence = PRECEDENCE_LOGIG_EQ;
         break;
 
       case NE:
         mPrecedence = PRECEDENCE_LOGIG_NE;
         break;
 
       case GT:
         mPrecedence = PRECEDENCE_LOGIG_GT;
         break;
 
       case GE:
         mPrecedence = PRECEDENCE_LOGIG_GE;
         break;
 
       case LT:
         mPrecedence = PRECEDENCE_LOGIG_LT;
         break;
 
       case LE:
         mPrecedence = PRECEDENCE_LOGIG_LE;
         break;
     }
 }

CEvaluationNodeLogical::CEvaluationNodeLogical ( const CEvaluationNodeLogical & src )

Copy constructor

Parameters

const CEvaluationNodeLogical & src

Definition at line 73 of file CEvaluationNodeLogical.cpp.

                                                                                 :
   CEvaluationNode(src),
   mpLeft(NULL),
   mpRight(NULL)
 {}

CEvaluationNodeLogical::~CEvaluationNodeLogical ( )

virtual

Destructor

Definition at line 79 of file CEvaluationNodeLogical.cpp.

79 {}

Member Function Documentation

virtual void CEvaluationNodeLogical::calculate ( void )

inlinevirtual

Calculate the numerical result of the node. It is assumed that all child nodes are up to date.

Reimplemented from CEvaluationNode.

Definition at line 84 of file CEvaluationNodeLogical.h.

References AND, EQ, GE, CEvaluationNode::getValue(), GT, LE, LT, mpLeft, mpRight, CEvaluationNode::mType, CEvaluationNode::mValue, NE, OR, and XOR.

   {
     switch (mType & 0x00FFFFFF)
       {
         case OR:
           mValue = (mpLeft->getValue() > 0.5 ||
                     mpRight->getValue() > 0.5) ? 1.0 : 0.0;
           break;
 
         case XOR:
           mValue = ((mpLeft->getValue() > 0.5 && mpRight->getValue() < 0.5) ||
                     (mpLeft->getValue() < 0.5 && mpRight->getValue() > 0.5)) ? 1.0 : 0.0;
           break;
 
         case AND:
           mValue = (mpLeft->getValue() > 0.5 &&
                     mpRight->getValue() > 0.5) ? 1.0 : 0.0;
           break;
 
         case EQ:
           mValue = (mpLeft->getValue() == mpRight->getValue()) ? 1.0 : 0.0;
           break;
 
         case NE:
           mValue = (mpLeft->getValue() != mpRight->getValue()) ? 1.0 : 0.0;
           break;
 
         case GT:
           mValue = (mpLeft->getValue() > mpRight->getValue()) ? 1.0 : 0.0;
           break;
 
         case GE:
           mValue = (mpLeft->getValue() >= mpRight->getValue()) ? 1.0 : 0.0;
           break;
 
         case LT:
           mValue = (mpLeft->getValue() < mpRight->getValue()) ? 1.0 : 0.0;
           break;
 
         case LE:
           mValue = (mpLeft->getValue() <= mpRight->getValue()) ? 1.0 : 0.0;
           break;
       }
   }

bool CEvaluationNodeLogical::compile ( const CEvaluationTree * pTree )

virtual

Compile a node;

Parameters

const CEvaluationTree * pTree

Returns: bool success;

Reimplemented from CEvaluationNode.

Definition at line 81 of file CEvaluationNodeLogical.cpp.

References CCopasiNode< std::string >::getChild(), CCopasiNode< _Data >::getSibling(), mpLeft, and mpRight.

Referenced by getBerkeleyMadonnaString(), getCCodeString(), getDisplayString(), getInfix(), getMMLString(), and getXPPString().

 {
   mpLeft = static_cast<CEvaluationNode *>(getChild());
 
   if (mpLeft == NULL) return false;
 
   mpRight = static_cast<CEvaluationNode *>(mpLeft->getSibling());
 
   if (mpRight == NULL) return false;
 
   return (mpRight->getSibling() == NULL); // We must have exactly two children
 }

CEvaluationNode * CEvaluationNodeLogical::fromAST	(	const ASTNode *	pASTNode,
		const std::vector< CEvaluationNode * > &	children
	)

static

Creates a new CEvaluationNodeCall from an ASTNode and the given children

Parameters

const	ASTNode* pNode
const	std::vector< CEvaluationNode * > & children

Returns: CEvaluationNode * pCretedNode

Definition at line 357 of file CEvaluationNodeLogical.cpp.

References CCopasiNode< _Data >::addChild(), AND, CEvaluationNodeLogical(), EQ, CEvaluationNodeConstant::FALSE, GE, GT, INVALID, LE, LT, NE, OR, CEvaluationNode::subType(), CEvaluationNodeConstant::TRUE, and XOR.

Referenced by CEvaluationTree::fromAST().

 {
   assert(pASTNode->getNumChildren() == children.size());
 
   size_t i = 0;
   size_t iMax = children.size();
 
   SubType subType;
   std::string data = "";
 
   switch (pASTNode->getType())
     {
       case AST_LOGICAL_AND:
         subType = AND;
         data = "and";
         break;
 
       case AST_LOGICAL_OR:
         subType = OR;
         data = "or";
         break;
 
       case AST_LOGICAL_XOR:
         subType = XOR;
         data = "xor";
         break;
 
       case AST_RELATIONAL_EQ:
         subType = EQ;
         data = "eq";
         break;
 
       case AST_RELATIONAL_GEQ:
         subType = GE;
         data = "ge";
         break;
 
       case AST_RELATIONAL_GT:
         subType = GT;
         data = "gt";
         break;
 
       case AST_RELATIONAL_LEQ:
         subType = LE;
         data = "le";
         break;
 
       case AST_RELATIONAL_LT:
         subType = LT;
         data = "lt";
         break;
 
       case AST_RELATIONAL_NEQ:
         subType = NE;
         data = "ne";
         break;
 
       default:
         subType = INVALID;
         break;
     }
 
   CEvaluationNode* pNode = NULL;
   // convert the two children
 
   switch (subType)
     {
       case AND:
       case OR:
       case XOR:
 
         // The number of chidren may vary
         switch (iMax)
           {
             case 0:
 
               if (subType == AND)
                 pNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::TRUE, "TRUE");
               else
                 pNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::FALSE, "FALSE");
 
               break;
 
             case 1:
               pNode = children[0];
               break;
 
             default:
             {
               pNode = new CEvaluationNodeLogical(subType, data);
               CEvaluationNode * pCurrent = pNode;
 
               // We have at least 2 children
               while (i < iMax - 1)
                 {
                   // add the first value
                   pCurrent->addChild(children[i++]);
 
                   switch (iMax - i)
                     {
                       case 1:
                         // We have only 1 more child
                         pCurrent->addChild(children[i++]);
                         break;
 
                       default:
                         // We have at least 2 more children
                       {
                         // create a new node with the same operator
                         CEvaluationNode * pTmp = new CEvaluationNodeLogical(subType, data);
                         pCurrent->addChild(pTmp);
                         pCurrent = pTmp;
                       }
                       break;
                     }
                 }
             }
             break;
           }
 
         break;
 
       case EQ:
       case NE:
       case GE:
       case GT:
       case LE:
       case LT:
         // all these are binary
         assert(iMax == 2);
         pNode = new CEvaluationNodeLogical(subType, data);
         pNode->addChild(children[0]);
         pNode->addChild(children[1]);
         break;
 
       case INVALID:
         // do nothing
         break;
     }
 
   return pNode;
 }

std::string CEvaluationNodeLogical::getBerkeleyMadonnaString ( const std::vector< std::string > & children ) const

virtual

Retrieve the display string of the node and its eventual child nodes in Berkeley Madonna format.

Returns: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 223 of file CEvaluationNodeLogical.cpp.

References AND, compile(), EQ, GE, CEvaluationNode::getType(), GT, LE, LT, mpLeft, mpRight, NE, OR, and CEvaluationNode::subType().

 {
   if (const_cast<CEvaluationNodeLogical *>(this)->compile(NULL))
     {
       Data DisplayString;
       Data data;
 
       switch ((SubType)CEvaluationNode::subType(this->getType()))
         {
           case AND:
             data = "AND";
             break;
 
           case OR:
             data = "OR";
             break;
 
             /* case XOR:
                break; */
           case EQ:
             data = "=";
             break;
 
           case GE:
             data = ">=";
             break;
 
           case GT:
             data = ">";
             break;
 
           case LE:
             data = "<=";
             break;
 
           case LT:
             data = "<";
             break;
 
           case NE:
             data = "<>";
             break;
 
           default:
             data = "@";
             break;
         }
 
       if (*mpLeft < * (CEvaluationNode *)this)
         DisplayString = "(" + children[0] + ")";
       else
         DisplayString = children[0] + " ";
 
       DisplayString += data;
 
       if (!(*(CEvaluationNode *)this < *mpRight))
         DisplayString += "(" + children[1] + ")";
       else
         DisplayString += " " + children[1];
 
       return DisplayString;
     }
   else
     return "@";
 }

std::string CEvaluationNodeLogical::getCCodeString ( const std::vector< std::string > & children ) const

virtual

Retrieve the display string of the node and its eventual child nodes in C.

Returns: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 145 of file CEvaluationNodeLogical.cpp.

References AND, compile(), EQ, GE, CEvaluationNode::getType(), GT, LE, LT, mpLeft, mpRight, NE, OR, and CEvaluationNode::subType().

 {
   if (const_cast<CEvaluationNodeLogical *>(this)->compile(NULL))
     {
       Data DisplayString;
       Data data;
       bool isXor = false;
 
       switch ((SubType)CEvaluationNode::subType(this->getType()))
         {
           case AND:
             data = "&&";
             break;
 
           case OR:
             data = "||";
             break;
 
           case EQ:
             data = "==";
             break;
 
           case GE:
             data = ">=";
             break;
 
           case GT:
             data = ">";
             break;
 
           case LE:
             data = "<=";
             break;
 
           case LT:
             data = "<";
             break;
 
           case NE:
             data = "!=";
             break;
 
           default:
             /*
              * case XOR:
              */
             data = "!=";
             isXor = true;
             break;
         }
 
       if (isXor)
         DisplayString = " !";
       else
         DisplayString = "";
 
       if (*mpLeft < * (CEvaluationNode *)this)
         DisplayString += "(" + children[0] + ")";
       else
         DisplayString += children[0] + " ";
 
       DisplayString += data;
 
       if (isXor)
         DisplayString += " !";
 
       if (!(*(CEvaluationNode *)this < *mpRight))
         DisplayString += "(" + children[1] + ")";
       else
         DisplayString += " " + children[1];
 
       return DisplayString;
     }
   else
     return "@";
 }

std::string CEvaluationNodeLogical::getDisplayString ( const std::vector< std::string > & children ) const

virtual

Retrieve the display string of the node and its eventual child nodes.

Returns: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 120 of file CEvaluationNodeLogical.cpp.

References compile(), CCopasiNode< std::string >::mData, mpLeft, and mpRight.

 {
   if (const_cast<CEvaluationNodeLogical *>(this)->compile(NULL))
     {
       Data DisplayString;
 
       if (*mpLeft < * (CEvaluationNode *)this)
         DisplayString = "(" + children[0] + ")";
       else
         DisplayString = children[0] + " ";
 
       DisplayString += mData;
 
       if (!(*(CEvaluationNode *)this < *mpRight))
         DisplayString += "(" + children[1] + ")";
       else
         DisplayString += " " + children[1];
 
       return DisplayString;
     }
   else
     return "@";
 }

std::string CEvaluationNodeLogical::getInfix ( const std::vector< std::string > & children ) const

virtual

Retrieve the infix value of the node and its eventual child nodes.

Returns: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 95 of file CEvaluationNodeLogical.cpp.

References compile(), CCopasiNode< std::string >::mData, mpLeft, and mpRight.

 {
   if (const_cast<CEvaluationNodeLogical *>(this)->compile(NULL))
     {
       Data Infix;
 
       if (*mpLeft < * (CEvaluationNode *)this)
         Infix = "(" + children[0] + ")";
       else
         Infix = children[0];
 
       Infix += " " + mData + " ";
 
       if (!(*(CEvaluationNode *)this < *mpRight))
         Infix += "(" + children[1] + ")";
       else
         Infix += children[1];
 
       return Infix;
     }
   else
     return "@";
 }

std::string CEvaluationNodeLogical::getMMLString	(	const std::vector< std::string > &	children,
		bool	expand,
		const std::vector< std::vector< std::string > > &	variables
	)		const

virtual

Build the MathML string

Parameters

const	std::vector< std::string > & children
bool	expand = true
const	std::vector< std::vector< std::string > > & variables

Returns: std::string MMLString

Reimplemented from CEvaluationNode.

Definition at line 569 of file CEvaluationNodeLogical.cpp.

References AND, compile(), EQ, GE, CEvaluationNode::getType(), GT, LE, LT, mpLeft, mpRight, NE, OR, CEvaluationNode::subType(), and XOR.

 {
   std::ostringstream out;
 
   if (const_cast<CEvaluationNodeLogical *>(this)->compile(NULL))
     {
       std::string data = "";
       bool flag = false;
 
       switch ((SubType)CEvaluationNode::subType(this->getType()))
         {
           case AND:
             data = " and ";
             break;
 
           case OR:
             data = " or ";
             break;
 
           case XOR:
             data = " xor ";
             break;
 
           case EQ:
             data = "=";
             break;
 
           case GE:
             data = "&gt;=";
             break;
 
           case GT:
             data = "&gt;";
             break;
 
           case LE:
             data = "&lt;=";
             break;
 
           case LT:
             data = "&lt;";
             break;
 
           case NE:
             data = "&NotEqual;";
             break;
 
           default:
             /*
              *
              */
             data = "@";
             break;
         }
 
       out << "<mrow>" << std::endl;
 
       flag = ((*mpLeft < * (CEvaluationNode *)this));
 
       if (flag) out << "<mfenced>" << std::endl;
 
       out << children[0];
 
       if (flag) out << "</mfenced>" << std::endl;
 
       out << "<mo>" << data << "</mo>" << std::endl;
 
       flag = ((*(CEvaluationNode *)this < *mpRight));
 
       if (!flag) out << "<mfenced>" << std::endl;
 
       out << children[1];
 
       if (!flag) out << "</mfenced>" << std::endl;
 
       out << "</mrow>" << std::endl;
     }
 
   return out.str();
 }

std::string CEvaluationNodeLogical::getXPPString ( const std::vector< std::string > & children ) const

virtual

Retrieve the display string of the node and its eventual child nodes in XPPAUT format.

Returns: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 290 of file CEvaluationNodeLogical.cpp.

References AND, compile(), EQ, GE, CEvaluationNode::getType(), GT, LE, LT, mpLeft, mpRight, NE, OR, CEvaluationNode::subType(), and CCopasiMessage::WARNING.

 {
   if (const_cast<CEvaluationNodeLogical *>(this)->compile(NULL))
     {
       Data DisplayString;
       Data data;
 
       switch ((SubType)CEvaluationNode::subType(this->getType()))
         {
           case AND:
             data = "&";
             break;
 
           case OR:
             data = "|";
             break;
 
           case EQ:
             data = "==";
             break;
 
           case GE:
             data = ">=";
             break;
 
           case GT:
             data = ">";
             break;
 
           case LE:
             data = "<=";
             break;
 
           case LT:
             data = "<";
             break;
 
           case NE:
             data = "!=";
             break;
 
           default:
             /* case XOR: */
             CCopasiMessage(CCopasiMessage::WARNING, " TODO   ");
             data = "@"; //TODO
             break;
         }
 
       if (*mpLeft < * (CEvaluationNode *)this)
         DisplayString = "(" + children[0] + ")";
       else
         DisplayString = children[0] + " ";
 
       DisplayString += data;
 
       if (!(*(CEvaluationNode *)this < *mpRight))
         DisplayString += "(" + children[1] + ")";
       else
         DisplayString += " " + children[1];
 
       return DisplayString;
     }
   else
     return "@"; //TODO
 }

bool CEvaluationNodeLogical::isBoolean ( ) const

virtual

Check whether the result is Boolean

Returns: bool isBoolean

Reimplemented from CEvaluationNode.

Definition at line 501 of file CEvaluationNodeLogical.cpp.

502 {return true;}

ASTNode * CEvaluationNodeLogical::toAST ( const CCopasiDataModel * pDataModel ) const

virtual

Create a new ASTNode corresponding to this OperatorNode.

Returns: ASTNode* return a pointer to the newly created node;

Reimplemented from CEvaluationNode.

Definition at line 504 of file CEvaluationNodeLogical.cpp.

References CCopasiNode< _Data >::addChild(), AND, EQ, GE, CCopasiNode< std::string >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), GT, INVALID, LE, LT, NE, OR, CEvaluationNode::subType(), CEvaluationNode::toAST(), and XOR.

 {
   SubType subType = (SubType)CEvaluationNode::subType(this->getType());
   ASTNode* node = new ASTNode();
 
   switch (subType)
     {
       case AND:
         node->setType(AST_LOGICAL_AND);
         break;
 
       case OR:
         node->setType(AST_LOGICAL_OR);
         break;
 
       case XOR:
         node->setType(AST_LOGICAL_XOR);
         break;
 
       case EQ:
         node->setType(AST_RELATIONAL_EQ);
         break;
 
       case NE:
         node->setType(AST_RELATIONAL_NEQ);
         break;
 
       case GT:
         node->setType(AST_RELATIONAL_GT);
         break;
 
       case GE:
         node->setType(AST_RELATIONAL_GEQ);
         break;
 
       case LT:
         node->setType(AST_RELATIONAL_LT);
         break;
 
       case LE:
         node->setType(AST_RELATIONAL_LEQ);
         break;
 
       case INVALID:
         break;
 
       default:
         subType = INVALID;
         break;
     }
 
   if (subType != INVALID)
     {
       const CEvaluationNode* child1 = dynamic_cast<const CEvaluationNode*>(this->getChild());
       const CEvaluationNode* child2 = dynamic_cast<const CEvaluationNode*>(child1->getSibling());
       node->addChild(child1->toAST(pDataModel));
       node->addChild(child2->toAST(pDataModel));
     }
 
   return node;
 }

Member Data Documentation

CEvaluationNode* CEvaluationNodeLogical::mpLeft

private

Definition at line 201 of file CEvaluationNodeLogical.h.

Referenced by calculate(), compile(), getBerkeleyMadonnaString(), getCCodeString(), getDisplayString(), getInfix(), getMMLString(), and getXPPString().

CEvaluationNode* CEvaluationNodeLogical::mpRight

private

Definition at line 203 of file CEvaluationNodeLogical.h.

Referenced by calculate(), compile(), getBerkeleyMadonnaString(), getCCodeString(), getDisplayString(), getInfix(), getMMLString(), and getXPPString().

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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation