#include <CEvaluationNodeObject.h>

Inheritance diagram for CEvaluationNodeObject:

Collaboration diagram for CEvaluationNodeObject:

Public Types
enum	SubType { INVALID = 0x00FFFFFF, CN = 0x00000000, POINTER = 0x00000001 }

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
	CEvaluationNodeObject (const SubType &subType, const Data &data)

	CEvaluationNodeObject (const C_FLOAT64 *pValue)

	CEvaluationNodeObject (const CEvaluationNodeObject &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 const Data &	getData () 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

const CRegisteredObjectName &	getObjectCN () const

const CObjectInterface *	getObjectInterfacePtr () const

const C_FLOAT64 *	getObjectValuePtr () const

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

virtual bool	setData (const Data &data)

void	setObjectValuePtr (C_FLOAT64 *pObjectValue)

virtual ASTNode *	toAST (const CCopasiDataModel *pDataModel) const

virtual	~CEvaluationNodeObject ()

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

virtual void	calculate ()

	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	isBoolean () 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

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	~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
	CEvaluationNodeObject ()

Private Attributes
const CObjectInterface *	mpObject

CRegisteredObjectName	mRegisteredObjectCN

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 class for nodes presenting numbers used in an evaluation trees

Definition at line 34 of file CEvaluationNodeObject.h.

Member Enumeration Documentation

enum CEvaluationNodeObject::SubType

Enumeration of possible node types. The typing of variables must be handled by the tree.

Enumerator
INVALID
CN
POINTER

Definition at line 41 of file CEvaluationNodeObject.h.

   {
     INVALID = 0x00FFFFFF,
     CN = 0x00000000,
     POINTER = 0x00000001
   };

Constructor & Destructor Documentation

CEvaluationNodeObject::CEvaluationNodeObject ( )

private

Default constructor

Definition at line 34 of file CEvaluationNodeObject.cpp.

References CEvaluationNode::mPrecedence, and PRECEDENCE_NUMBER.

Referenced by fromAST().

                                             :
   CEvaluationNode(CEvaluationNode::INVALID, ""),
   mpObject(NULL),
   mRegisteredObjectCN("")
 {mPrecedence = PRECEDENCE_NUMBER;}

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

Default constructor

Parameters

const	SubType & subType
const	Data & data

Definition at line 40 of file CEvaluationNodeObject.cpp.

References CEvaluationNode::mPrecedence, and PRECEDENCE_NUMBER.

                       :
   CEvaluationNode((Type)(CEvaluationNode::OBJECT | subType), data),
   mpObject(NULL),
   mRegisteredObjectCN(data.substr(1, data.length() - 2))
 {
   mPrecedence = PRECEDENCE_NUMBER;
 }

CEvaluationNodeObject::CEvaluationNodeObject ( const C_FLOAT64 * pValue )

Specific constructor

Parameters

const Data & data

Definition at line 49 of file CEvaluationNodeObject.cpp.

References CCopasiNode< std::string >::mData, CEvaluationNode::mPrecedence, CEvaluationNode::mpValue, pointerToString(), and PRECEDENCE_NUMBER.

                                                                     :
   CEvaluationNode((Type)(CEvaluationNode::OBJECT | POINTER), "pointer"),
   mpObject(NULL),
   mRegisteredObjectCN("")
 {
   mPrecedence = PRECEDENCE_NUMBER;
   mpValue = pValue;
   mData = pointerToString(pValue);
 }

CEvaluationNodeObject::CEvaluationNodeObject ( const CEvaluationNodeObject & src )

Copy constructor

Parameters

const CEvaluationNodeObject & src

Definition at line 59 of file CEvaluationNodeObject.cpp.

References CEvaluationNode::mpValue.

                                                                              :
   CEvaluationNode(src),
   mpObject(src.mpObject),
   mRegisteredObjectCN(src.mRegisteredObjectCN)
 {
   mpValue = src.mpValue;
 }

CEvaluationNodeObject::~CEvaluationNodeObject ( )

virtual

Destructor

Definition at line 67 of file CEvaluationNodeObject.cpp.

67 {}

Member Function Documentation

bool CEvaluationNodeObject::compile ( const CEvaluationTree * pTree )

virtual

Compile a node;

Parameters

const CEvaluationTree * pTree

Returns: bool success;

Reimplemented from CEvaluationNode.

Definition at line 69 of file CEvaluationNodeObject.cpp.

References C_FLOAT64, CN, CCopasiNode< std::string >::getChild(), CObjectInterface::getCN(), getData(), CExpression::getNodeObject(), CCopasiObject::getValueObject(), CObjectInterface::getValuePointer(), INVALID, CCopasiObject::isValueDbl(), CCopasiNode< std::string >::mData, mpObject, CEvaluationNode::mpValue, mRegisteredObjectCN, CEvaluationNode::mType, CEvaluationNode::mValue, POINTER, stringToPointer(), and CEvaluationNode::subType().

 {
   mpObject = NULL;
   mpValue = NULL;
 
   switch ((int) subType(mType))
     {
       case CN:
       {
         const CExpression * pExpression = dynamic_cast< const CExpression * >(pTree);
 
         if (!pExpression) return false;
 
         mpObject =
           pExpression->getNodeObject(mRegisteredObjectCN);
 
         const CCopasiObject * pDataObject = dynamic_cast< const CCopasiObject * >(mpObject);
 
         if (pDataObject != NULL)
           {
             // We may have some container objects for which the value is an included
             // reference. For the math model to work this needs to be corrected.
             const CObjectInterface * pObject = pDataObject->getValueObject();
 
             if (mpObject != pObject && pObject != NULL)
               {
                 mpObject = pObject;
                 mRegisteredObjectCN = mpObject->getCN();
                 mData = getData();
               }
 
             if (pDataObject->isValueDbl())
               {
                 mpValue = (C_FLOAT64 *) mpObject->getValuePointer();
               }
           }
         else if (mpObject != NULL)
           {
             mpValue = (C_FLOAT64 *) mpObject->getValuePointer();
           }
 
         if (mpValue == NULL)
           {
             mValue = std::numeric_limits<C_FLOAT64>::quiet_NaN();
             mpValue = &mValue;
             return false;
           }
 
         mData = "<" + mRegisteredObjectCN + ">";
       }
       break;
 
       case POINTER:
         // We need to convert the data into a pointer
       {
         mpValue = (const C_FLOAT64 *) stringToPointer(mData);
       }
       break;
 
       case INVALID:
         break;
     }
 
   return (getChild() == NULL); // We must not have any children.
 }

CEvaluationNode * CEvaluationNodeObject::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 226 of file CEvaluationNodeObject.cpp.

References CEvaluationNodeObject(), and CN.

Referenced by CEvaluationTree::fromAST().

 {
   assert(pASTNode->getNumChildren() == children.size());
 
   CEvaluationNodeObject* pNode = NULL;
 
   switch (pASTNode->getType())
     {
       case AST_NAME_AVOGADRO:
       case AST_NAME_TIME:
       case AST_NAME:
         pNode = new CEvaluationNodeObject(CN, CCopasiObjectName(std::string("<") + pASTNode->getName() + std::string(">")));
         break;
 
       default:
         break;
     }
 
   return pNode;
 }

std::string CEvaluationNodeObject::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 214 of file CEvaluationNodeObject.cpp.

References CCopasiNode< std::string >::mData.

 {
   return mData;
 }

std::string CEvaluationNodeObject::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 208 of file CEvaluationNodeObject.cpp.

References CCopasiNode< std::string >::mData.

 {
   return mData;
 }

const CEvaluationNode::Data & CEvaluationNodeObject::getData ( ) const

virtual

Retrieve the value of the node.

Returns: const Data & value

Reimplemented from CCopasiNode< std::string >.

Definition at line 135 of file CEvaluationNodeObject.cpp.

References CN, CCopasiNode< std::string >::mData, mRegisteredObjectCN, CEvaluationNode::mType, POINTER, and CEvaluationNode::subType().

Referenced by compile(), SBMLImporter::doMapping(), CReaction::object2variable(), SBMLImporter::renameMassActionParameters(), and SBMLImporter::setCorrectUsage().

 {
   static std::string data;
 
   switch ((int) subType(mType))
     {
       case CN:
         return data = "<" + mRegisteredObjectCN + ">";
         break;
 
       case POINTER:
         return mData;
         break;
     }
 
   return mData;
 }

std::string CEvaluationNodeObject::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 197 of file CEvaluationNodeObject.cpp.

References CCopasiObject::getObjectDisplayName(), mpObject, and mRegisteredObjectCN.

 {
   const CCopasiObject* object = dynamic_cast<const CCopasiObject*>(mpObject);
 
   if (object != NULL)
     return object->getObjectDisplayName();
 
   return "<" + mRegisteredObjectCN + ">";
 }

std::string CEvaluationNodeObject::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 164 of file CEvaluationNodeObject.cpp.

References CN, CCopasiNode< std::string >::mData, mRegisteredObjectCN, CEvaluationNode::mType, POINTER, and CEvaluationNode::subType().

 {
   switch ((int) subType(mType))
     {
       case CN:
         return "<" + mRegisteredObjectCN + ">";
         break;
 
       case POINTER:
         return mData;
         break;
     }
 
   return mData;
 }

std::string CEvaluationNodeObject::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 390 of file CEvaluationNodeObject.cpp.

References CMathObject::getDataObject(), CMathMl::getMMLName(), and mpObject.

 {
   std::ostringstream out;
 
   const CCopasiObject * pDataObject = dynamic_cast< const CCopasiObject * >(mpObject);
 
   if (pDataObject == NULL)
     {
       const CMathObject * pMathObject = dynamic_cast< const CMathObject * >(mpObject);
 
       if (pMathObject != NULL)
         {
           pDataObject = pMathObject->getDataObject();
         }
     }
 
   out << CMathMl::getMMLName(pDataObject) << std::endl;
 
   return out.str();
 }

const CRegisteredObjectName & CEvaluationNodeObject::getObjectCN ( ) const

Retrieve the CN of the referred object.

Returns: const CRegisteredObjectName & objectCN

Definition at line 351 of file CEvaluationNodeObject.cpp.

References mRegisteredObjectCN.

352 {return mRegisteredObjectCN;}

CEvaluationNodeObject::mRegisteredObjectCN

CRegisteredObjectName mRegisteredObjectCN

Definition: CEvaluationNodeObject.h:192

const CObjectInterface * CEvaluationNodeObject::getObjectInterfacePtr ( ) const

Retrieve the pointer to the referred object interface

Returns: const CObjectInterface * pObjectInterface

Definition at line 354 of file CEvaluationNodeObject.cpp.

References mpObject.

Referenced by CModelExpansion::expressionContainsObject(), CModelExpansion::replaceInExpression(), and CModelExpansion::updateExpression().

 {
   return mpObject;
 }

const C_FLOAT64 * CEvaluationNodeObject::getObjectValuePtr ( ) const

Retrieve the pointer to the value of the referred object

Returns: const C_FLOAT64 * pObjectValue

Definition at line 359 of file CEvaluationNodeObject.cpp.

References CEvaluationNode::mpValue.

Referenced by CMathExpression::convertToInitialExpression().

 {
   return mpValue;
 }

std::string CEvaluationNodeObject::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 220 of file CEvaluationNodeObject.cpp.

References CCopasiNode< std::string >::mData.

 {
   return mData;
 }

bool CEvaluationNodeObject::setData ( const Data & data )

virtual

Set the data of the Node.

Parameters

const Data & data

Returns: bool success

Reimplemented from CCopasiNode< std::string >.

Definition at line 153 of file CEvaluationNodeObject.cpp.

References CN, CCopasiNode< std::string >::mData, mRegisteredObjectCN, CEvaluationNode::mType, and CEvaluationNode::subType().

Referenced by CModelAdd::copyDelayExpression(), CModelAdd::copyEventAssignmentExpression(), CModelAdd::copyExpression(), CModelAdd::copyInitialExpression(), CModelAdd::copyTriggerExpression(), CExpression::createInitialExpression(), CModelMerging::mergeInExpression(), SBMLImporter::renameMassActionParameters(), CModelExpansion::replaceInExpression(), and CModelExpansion::updateExpression().

 {
   mData = data;
 
   if ((int) subType(mType) == (int) CN)
     mRegisteredObjectCN = data.substr(1, data.length() - 2);
 
   return true;
 }

void CEvaluationNodeObject::setObjectValuePtr ( C_FLOAT64 * pObjectValue )

Set the pointer to the value of the referred object

Parameters

C_FLOAT64 * pObjectValue

Definition at line 364 of file CEvaluationNodeObject.cpp.

References CN, CCopasiNode< std::string >::mData, CEvaluationNode::mpValue, CEvaluationNode::mType, POINTER, pointerToString(), and CEvaluationNode::subType().

Referenced by CMathExpression::convertToInitialExpression().

 {
   assert(pObjectValue);
 
   switch ((int) subType(mType))
     {
       case CN:
         break;
 
       case POINTER:
 
         if (mpValue != pObjectValue)
           {
             mpValue = pObjectValue;
             mData = pointerToString(mpValue);
           }
 
         break;
     }
 
   return;
 }

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

virtual

Converts this node to an ASTNode.

Returns: ASTNode the resulting ASTNode.

Reimplemented from CEvaluationNode.

Definition at line 247 of file CEvaluationNodeObject.cpp.

References fatalError, CCopasiNode< std::string >::getChild(), CCopasiParameter::getCN(), CCopasiDataModel::getDataObject(), CModel::getInitialTime(), getObjectCN(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CModelEntity::getSBMLId(), CReaction::getSBMLId(), CCopasiObject::isReference(), MCSBML, mRegisteredObjectCN, CEvaluationNode::toAST(), and CCopasiMessage::WARNING.

 {
   ASTNode* node = new ASTNode();
   node->setType(AST_NAME);
 
   if (mRegisteredObjectCN == "rateOf")
     {
       node->setType(AST_FUNCTION);
       const CEvaluationNode* child = dynamic_cast<const CEvaluationNode*>(this->getChild());
 
       if (child == NULL) fatalError();
 
       const CEvaluationNodeObject* sibling = dynamic_cast<const CEvaluationNodeObject*>(this->getChild()->getSibling());
 
       if (sibling == NULL) fatalError();
 
       node->setName(sibling->getObjectCN().c_str());
       node->addChild(child->toAST(pDataModel));
       return node;
     }
 
   // since I can not get the model in which this node is located, I just
   // assume that it will always be the current global model.
   const CCopasiObject* pOrigObject = pDataModel->getDataObject(mRegisteredObjectCN);
 
   if (pOrigObject == NULL)
     {
       node->setName(mRegisteredObjectCN.c_str());
       return node;
     }
 
   const CCopasiObject* pObject = pOrigObject;
 
   // if it is a reference, we get the parent of the reference
   if (pObject->isReference())
     {
       pObject = pObject->getObjectParent();
     }
 
   const CModelEntity* pME = dynamic_cast<const CModelEntity*>(pObject);
 
   if (pME != NULL)
     {
       const CModel* pModel = dynamic_cast<const CModel*>(pME);
 
       if (pModel != NULL)
         {
 #if LIBSBML_VERSION >= 40100
 
           if (pOrigObject->getObjectName() == "Avogadro Constant")
             {
               node->setType(AST_NAME_AVOGADRO);
               node->setName("avogadro");
             }
           else
             {
 #endif // LIBSBML_VERSION >= 40100
               node->setType(AST_NAME_TIME);
               node->setName("time");
 
               if (pModel->getInitialTime() != 0.0)
                 {
                   CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 1);
                 }
 
 #if LIBSBML_VERSION >= 40100
             }
 
 #endif // LIBSBML_VERSION >= 40100
         }
       else
         {
           node->setName(pME->getSBMLId().c_str());
         }
     }
   else
     {
       const CCopasiParameter* pPara = dynamic_cast<const CCopasiParameter*>(pObject);
 
       if (pPara != NULL)
         {
           // now we have to use the common name as the name for the
           // node since we need to be able to identify local parameters
           // in arbitrary expressions for the export
           node->setName(pPara->getCN().c_str());
         }
       else
         {
           const CReaction* pReaction = dynamic_cast<const CReaction*>(pObject);
 
           if (pReaction)
             {
               node->setName(pReaction->getSBMLId().c_str());
             }
           else
             {
               fatalError();
             }
         }
     }
 
   return node;
 }

Member Data Documentation

const CObjectInterface* CEvaluationNodeObject::mpObject

private

Pointer to the object

Definition at line 187 of file CEvaluationNodeObject.h.

Referenced by compile(), getDisplayString(), getMMLString(), and getObjectInterfacePtr().

CRegisteredObjectName CEvaluationNodeObject::mRegisteredObjectCN

private

The registered object name to track eventual renaming.

Definition at line 192 of file CEvaluationNodeObject.h.

Referenced by compile(), getData(), getDisplayString(), getInfix(), getObjectCN(), setData(), and toAST().

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