CEvaluationNodeCall Class Reference

#include <CEvaluationNodeCall.h>

Inheritance diagram for CEvaluationNodeCall:

Collaboration diagram for CEvaluationNodeCall:

Public Types
enum	SubType { INVALID = 0x00FFFFFF, FUNCTION = 0x00000000, EXPRESSION = 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
virtual bool	addChild (CCopasiNode< Data > *pChild, CCopasiNode< Data > *pAfter=NULL)
virtual void	calculate ()
bool	calls (std::set< std::string > &list) const
	CEvaluationNodeCall (const SubType &subType, const Data &data)
	CEvaluationNodeCall (const CEvaluationNodeCall &src)
virtual bool	compile (const CEvaluationTree *pTree)
virtual std::string	getBerkeleyMadonnaString (const std::vector< std::string > &children) const
const CEvaluationTree *	getCalledTree () 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
const std::vector < CEvaluationNode * >	getListOfChildNodes () 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
const bool &	isBooleanRequired () const
virtual bool	removeChild (CCopasiNode< Data > *pChild)
void	setBooleanRequired (const bool &booleanRequired)
virtual bool	setData (const Data &data)
virtual ASTNode *	toAST (const CCopasiDataModel *pDataModel) const
virtual	~CEvaluationNodeCall ()
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 >
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	~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
	CEvaluationNodeCall ()

Static Private Member Functions
static CCallParameters < C_FLOAT64 > *	buildParameters (const std::vector< CEvaluationNode * > &vector)
static void	clearParameters (CCallParameters< C_FLOAT64 > *pCallParameters, const std::vector< CEvaluationNode * > &vector)
static bool	verifyParameters (const std::vector< CEvaluationNode * > &vector, const CFunctionParameters &functionParameters)

Private Attributes
bool	mBooleanRequired
std::vector< CEvaluationNode * >	mCallNodes
CCallParameters< C_FLOAT64 > *	mpCallParameters
CExpression *	mpExpression
CFunction *	mpFunction
bool	mQuotesRequired
CRegisteredObjectName	mRegisteredFunctionCN

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 operators used in an evaluation trees.

Definition at line 30 of file CEvaluationNodeCall.h.

Member Enumeration Documentation

enum CEvaluationNodeCall::SubType

Enumeration of possible node types.

Enumerator
INVALID
FUNCTION
EXPRESSION

Definition at line 36 of file CEvaluationNodeCall.h.

  {
    INVALID = 0x00FFFFFF,
    FUNCTION = 0x00000000,
    EXPRESSION = 0x00000001
  };

Constructor & Destructor Documentation

CEvaluationNodeCall::CEvaluationNodeCall ( )

private

Default constructor

Definition at line 28 of file CEvaluationNodeCall.cpp.

References CEvaluationNode::mPrecedence, and PRECEDENCE_NUMBER.

Referenced by fromAST().

                                        :
  CEvaluationNode(CEvaluationNode::INVALID, ""),
  mpFunction(NULL),
  mpExpression(NULL),
  mCallNodes(),
  mpCallParameters(NULL),
  mQuotesRequired(false),
  mBooleanRequired(false),
  mRegisteredFunctionCN()
{mPrecedence = PRECEDENCE_NUMBER;}

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

Default constructor

Parameters

const	SubType & subType
const	Data & data

Definition at line 39 of file CEvaluationNodeCall.cpp.

References EXPRESSION, fatalError, FUNCTION, CEvaluationNode::isKeyword(), CCopasiNode< std::string >::mData, CEvaluationNode::mPrecedence, mQuotesRequired, PRECEDENCE_FUNCTION, quote(), setData(), and unQuote().

                      :
  CEvaluationNode((Type)(CEvaluationNode::CALL | subType), data),
  mpFunction(NULL),
  mpExpression(NULL),
  mCallNodes(),
  mpCallParameters(NULL),
  mQuotesRequired(false),
  mBooleanRequired(false),
  mRegisteredFunctionCN()
{
  setData(data);
  mData = unQuote(mData);

  // We force quoting if the round trip unquote, quote does not recover the original input
  if (isKeyword(mData))
    {
      mQuotesRequired = true;
    }

  if (mData != data && quote(mData) != data)
    {
      mQuotesRequired = true;
    }

  switch (subType)
    {
      case FUNCTION:
      case EXPRESSION:
        break;

      default:
        fatalError();
        break;
    }

  mPrecedence = PRECEDENCE_FUNCTION;
}

CEvaluationNodeCall::CEvaluationNodeCall

(

const CEvaluationNodeCall &

src

)

Copy constructor

Parameters

const

CEvaluationNodeCall & src

Definition at line 78 of file CEvaluationNodeCall.cpp.

References buildParameters(), mCallNodes, and mpCallParameters.

                                                                       :
  CEvaluationNode(src),
  mpFunction(src.mpFunction),
  mpExpression(src.mpExpression),
  mCallNodes(src.mCallNodes),
  mpCallParameters(NULL),
  mQuotesRequired(src.mQuotesRequired),
  mBooleanRequired(src.mBooleanRequired),
  mRegisteredFunctionCN(src.mRegisteredFunctionCN)
{mpCallParameters = buildParameters(mCallNodes);}

CEvaluationNodeCall::~CEvaluationNodeCall ( )

virtual

Destructor

Definition at line 89 of file CEvaluationNodeCall.cpp.

{}

Member Function Documentation

bool CEvaluationNodeCall::addChild ( CCopasiNode< Data > *  pChild, CCopasiNode< Data > *  pAfter = NULL  )

virtual

Add a child to a node. If pAfter == this the child will be inserted at the front of the list of children.

Parameters

CCopasiNode<	Data > * pChild
CCopasiNode<	Data > * pAfter (default: NULL appended to the list of children)

Returns

bool Success

Reimplemented from CCopasiNode< std::string >.

Definition at line 465 of file CEvaluationNodeCall.cpp.

References CCopasiNode< _Data >::addChild(), and mCallNodes.

Referenced by SBMLImporter::createCReactionFromReaction(), CSBMLExporter::createKineticExpression(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeCall(), and test_compare_utilities::test_copasi_function_expansion().

{
  CCopasiNode< Data >::addChild(pChild, pAfter);

  if (pAfter == NULL)
    {
      mCallNodes.push_back(static_cast<CEvaluationNode *>(pChild));
      return true;
    }

  std::vector<CEvaluationNode *>::iterator it = mCallNodes.begin();

  if (pAfter != this)
    {
      std::vector<CEvaluationNode *>::iterator end = mCallNodes.end();

      while (it != end && *it != pAfter) ++it;
    }

  mCallNodes.insert(it, static_cast<CEvaluationNode *>(pChild));

  return true;
}

CCallParameters< C_FLOAT64 > * CEvaluationNodeCall::buildParameters ( const std::vector< CEvaluationNode * > &  vector )

staticprivate

Build the list of call parameters which correspond to the list of call nodes.

Definition at line 503 of file CEvaluationNodeCall.cpp.

References CEvaluationNode::type(), and CEvaluationNode::VECTOR.

Referenced by CEvaluationNodeCall(), and compile().

{
  std::vector<CEvaluationNode *>::const_iterator it = vector.begin();
  std::vector<CEvaluationNode *>::const_iterator end = vector.end();

  CCallParameters< C_FLOAT64 > * pCallParameters =
    new CCallParameters< C_FLOAT64 >(vector.size());
  size_t i;

  for (i = 0; it != end; ++it, i++)
    {
      if (type((*it)->getType()) == CEvaluationNode::VECTOR)
        (*pCallParameters)[i].vector = buildParameters(static_cast<const CEvaluationNodeVector *>(*it)->getVector());
      else
        (*pCallParameters)[i].value = (*it)->getValuePointer();
    }

  return pCallParameters;
}

void CEvaluationNodeCall::calculate ( void  )

virtual

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

Reimplemented from CEvaluationNode.

Definition at line 91 of file CEvaluationNodeCall.cpp.

References CExpression::calcValue(), CFunction::calcValue(), EXPRESSION, FUNCTION, mpCallParameters, mpExpression, mpFunction, CEvaluationNode::mType, and CEvaluationNode::mValue.

{
  switch (mType & 0x00FFFFFF)
    {
      case FUNCTION:
        mValue = mpFunction->calcValue(*mpCallParameters);
        break;

      case EXPRESSION:
        mValue = mpExpression->calcValue();
        break;

      default:
        mValue = std::numeric_limits<C_FLOAT64>::quiet_NaN();
        break;
    }
}

bool CEvaluationNodeCall::calls

(

std::set< std::string > &

list

)

const

Check whether node the calls any tree in the list

Parameters

std::set<

std::string > & list

Returns

bool calls

Definition at line 196 of file CEvaluationNodeCall.cpp.

References CEvaluationTree::calls(), CFunctionDB::findFunction(), CCopasiRootContainer::getFunctionList(), and CCopasiNode< std::string >::mData.

{
  if (list.count(mData)) return true;

  CEvaluationTree * pTree =
    CCopasiRootContainer::getFunctionList()->findFunction(mData);

  if (pTree) return pTree->calls(list);

  return false;
}

void CEvaluationNodeCall::clearParameters ( CCallParameters< C_FLOAT64 > *  pCallParameters, const std::vector< CEvaluationNode * > &  vector  )

staticprivate

Clear the list of call parameters.

Definition at line 524 of file CEvaluationNodeCall.cpp.

References CEvaluationNode::type(), and CEvaluationNode::VECTOR.

Referenced by compile().

{
  if (!pCallParameters) return;

  std::vector<CEvaluationNode *>::const_iterator it = vector.begin();
  std::vector<CEvaluationNode *>::const_iterator end = vector.end();

  size_t i;

  for (i = 0; it != end; ++it, i++)
    {
      if (type((*it)->getType()) == CEvaluationNode::VECTOR)
        clearParameters((*pCallParameters)[i].vector,
                        static_cast<const CEvaluationNodeVector *>(*it)->getVector());
    }

  delete pCallParameters;
  return;
}

bool CEvaluationNodeCall::compile ( const CEvaluationTree *  pTree )

virtual

Compile a node;

Parameters

const

CEvaluationTree * pTree

Returns

bool success;

Reimplemented from CEvaluationNode.

Definition at line 109 of file CEvaluationNodeCall.cpp.

References buildParameters(), CEvaluationNode::CALL, clearParameters(), CExpression::compile(), EXPRESSION, CFunctionDB::findFunction(), FUNCTION, CCopasiObject::getCN(), CCopasiRootContainer::getFunctionList(), CCopasiContainer::getObject(), CCopasiRootContainer::getRoot(), CFunction::getVariables(), mCallNodes, CCopasiNode< std::string >::mData, mpCallParameters, mpExpression, mpFunction, mRegisteredFunctionCN, CEvaluationNode::mType, and verifyParameters().

{
  bool success = true;
  clearParameters(mpCallParameters, mCallNodes);

  CObjectInterface * pObjectInterface = NULL;

  if (mRegisteredFunctionCN != "")
    {
      pObjectInterface = const_cast< CObjectInterface * >(CCopasiRootContainer::getRoot()->getObject(mRegisteredFunctionCN));
    }

  switch (mType & 0x00FFFFFF)
    {
      case FUNCTION:

        if (pObjectInterface != NULL)
          {
            mpFunction = dynamic_cast< CFunction * >(pObjectInterface);
          }
        else
          {
            mpFunction =
              dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
          }

        if (!mpFunction) return false;

        mRegisteredFunctionCN = mpFunction->getCN();

        // We need to check whether the provided arguments match the on needed by the
        // function;
        if (!verifyParameters(mCallNodes, mpFunction->getVariables())) return false;

        mpCallParameters = buildParameters(mCallNodes);
        break;

      case EXPRESSION:

        if (pObjectInterface != NULL)
          {
            mpExpression = dynamic_cast<CExpression *>(pObjectInterface);
          }
        else
          {
            mpExpression =
              dynamic_cast<CExpression *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
          }

        if (!mpExpression)
          {
            // We may have a function with no arguments the parser is not able to distinguish
            // between that and an expression.
            if (pObjectInterface != NULL)
              {
                mpFunction = dynamic_cast< CFunction * >(pObjectInterface);
              }
            else
              {
                mpFunction =
                  dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
              }

            if (!mpFunction) return false;

            mRegisteredFunctionCN = mpFunction->getCN();

            mType = (CEvaluationNode::Type)(CEvaluationNode::CALL | FUNCTION);
            success = compile(pTree);
          }
        else
          {
            mRegisteredFunctionCN = mpExpression->getCN();

            success = mpExpression->compile(static_cast<const CExpression *>(pTree)->getListOfContainer());
          }

        break;

      default:
        success = false;
        break;
    }

  return success;
}

CEvaluationNode * CEvaluationNodeCall::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 427 of file CEvaluationNodeCall.cpp.

References CEvaluationNode::addChildren(), CEvaluationNodeCall(), FUNCTION, and CEvaluationNode::subType().

Referenced by CEvaluationTree::fromAST().

{
  assert(pASTNode->getNumChildren() == children.size());

  SubType subType = CEvaluationNodeCall::FUNCTION;
  std::string data = pASTNode->getName();

  CEvaluationNodeCall * pNode = new CEvaluationNodeCall(subType, data);

  pNode->addChildren(children);

  return pNode;
}

std::string CEvaluationNodeCall::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 393 of file CEvaluationNodeCall.cpp.

References CCopasiNode< std::string >::mData, mQuotesRequired, and quote().

{
  std::string DisplayString;

  if (mQuotesRequired)
    {
      DisplayString = "\"" + quote(mData, "-+^*/%(){},\t\r\n\"") + "\"(";
    }
  else
    {
      DisplayString = quote(mData, "-+^*/%(){},\t\r\n") + "(";
    }

  return DisplayString;
}

const CEvaluationTree * CEvaluationNodeCall::getCalledTree

(

)

const

Retrieve the tree which is called from this node

Returns

const CEvaluationTree * calledTree

Definition at line 567 of file CEvaluationNodeCall.cpp.

References EXPRESSION, CFunctionDB::findFunction(), FUNCTION, CCopasiRootContainer::getFunctionList(), CCopasiNode< std::string >::mData, and CEvaluationNode::mType.

Referenced by CMathTrigger::compileFUNCTION(), CMathContainer::copyBranch(), CFunctionAnalyzer::evaluateNode(), CODEExporter::exportExpression(), isBoolean(), test000042::test_hasOnlySubstanceUnits(), and test000043::test_hasOnlySubstanceUnits().

{
  switch (mType & 0x00FFFFFF)
    {
      case FUNCTION:
      case EXPRESSION:
        return CCopasiRootContainer::getFunctionList()->findFunction(mData);

      default:
        return NULL;
    }
}

std::string CEvaluationNodeCall::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 345 of file CEvaluationNodeCall.cpp.

References EXPRESSION, FUNCTION, getData(), CCopasiNode< std::string >::mData, mQuotesRequired, CEvaluationNode::mType, and quote().

{
  std::string DisplayString;

  std::string Data;

  if (mData.empty())
    Data = getData();
  else
    Data = mData;

  if (mQuotesRequired)
    {
      DisplayString = "\"" + quote(Data, "-+^*/%(){},\t\r\n\"") + "\"(";
    }
  else
    {
      DisplayString = quote(Data, "-+^*/%(){},\t\r\n") + "(";
    }

  switch (mType & 0x00FFFFFF)
    {
      case FUNCTION:
      {

        std::vector< std::string >::const_iterator it = children.begin();
        std::vector< std::string >::const_iterator end = children.end();

        if (it != end) DisplayString += *it++;

        for (; it != end; ++it)
          DisplayString += "," + *it;
      }

      break;

      case EXPRESSION:
        break;

      default:
        return "@";
        break;
    }

  return DisplayString + ")";
}

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

virtual

Retrieve the value of the node.

Returns

const Data & value

Reimplemented from CCopasiNode< std::string >.

Definition at line 209 of file CEvaluationNodeCall.cpp.

References CCopasiObject::getObjectName(), CEvaluationNode::isKeyword(), CCopasiNode< std::string >::mData, mpExpression, mpFunction, mQuotesRequired, quote(), and unQuote().

Referenced by expand_function_call(), getCCodeString(), getInfix(), getMMLString(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeCall(), test000043::test_hasOnlySubstanceUnits(), test000042::test_hasOnlySubstanceUnits(), test000075::test_import_time_dependent_function_definition(), test000078::test_l2v4_import_unordered_functions(), and toAST().

{
  // We determine whether quoting is required here since we can not be sure
  // that the original infix is correct.

  std::string Data;

  if (isKeyword(mData))
    {
      mQuotesRequired = true;
    }

  if (mpFunction != NULL)
    {
      Data = mpFunction->getObjectName();
      mQuotesRequired |= mpFunction->getObjectName() != unQuote(quote(Data));

      return mpFunction->getObjectName();
    }

  if (mpExpression != NULL)
    {
      Data = mpExpression->getObjectName();
      mQuotesRequired |= mpExpression->getObjectName() != unQuote(quote(Data));

      return mpExpression->getObjectName();
    }

  return mData;
}

std::string CEvaluationNodeCall::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 305 of file CEvaluationNodeCall.cpp.

References EXPRESSION, FUNCTION, CCopasiNode< std::string >::mData, mQuotesRequired, CEvaluationNode::mType, and quote().

{
  std::string DisplayString;

  if (mQuotesRequired)
    {
      DisplayString = "\"" + quote(mData, "-+^*/%(){},\t\r\n\"") + "\"(";
    }
  else
    {
      DisplayString = quote(mData, "-+^*/%(){},\t\r\n") + "(";
    }

  switch (mType & 0x00FFFFFF)
    {
      case FUNCTION:
      {
        std::vector< std::string >::const_iterator it = children.begin();
        std::vector< std::string >::const_iterator end = children.end();

        if (it != end) DisplayString += *it++;

        for (; it != end; ++it)
          DisplayString += "," + *it;
      }

      break;

      case EXPRESSION:
        break;

      default:
        return "@";
        break;
    }

  return DisplayString + ")";
}

std::string CEvaluationNodeCall::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 262 of file CEvaluationNodeCall.cpp.

References EXPRESSION, FUNCTION, getData(), mQuotesRequired, CEvaluationNode::mType, and quote().

{
  std::string Infix;

  //We use getData instead of mData since getData also detects whether quoting is needed.
  const std::string & Data = getData();

  if (mQuotesRequired)
    {
      Infix = "\"" + quote(Data, "-+^*/%(){},\t\r\n\"") + "\"(";
    }
  else
    {
      Infix = quote(Data, "-+^*/%(){},\t\r\n") + "(";
    }

  switch (mType & 0x00FFFFFF)
    {
      case FUNCTION:
      {
        std::vector< std::string >::const_iterator it = children.begin();
        std::vector< std::string>::const_iterator end = children.end();

        if (it != end) Infix += *it++;

        for (; it != end; ++it)
          Infix += "," + *it;
      }

      break;

      case EXPRESSION:
        break;

      default:
        return "@";
        break;
    }

  return Infix + ")";
}

const std::vector<CEvaluationNode *> CEvaluationNodeCall::getListOfChildNodes ( ) const

inline

returns the vector of child nodes, corresponding to the arguments of a function call

Definition at line 188 of file CEvaluationNodeCall.h.

References mCallNodes.

Referenced by CFunctionAnalyzer::evaluateNode(), and CEvaluationNodeNormalizer::normalizeCEvaluationNodeCall().

{return mCallNodes;}

std::string CEvaluationNodeCall::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 583 of file CEvaluationNodeCall.cpp.

References EXPRESSION, CMathMl::fixName(), FUNCTION, getData(), mpFunction, mQuotesRequired, CEvaluationNode::mType, quote(), and CFunction::writeMathML().

{
  std::ostringstream out;

  std::vector< std::string >::const_iterator it = children.begin();
  std::vector< std::string >::const_iterator end = children.end();

  switch (mType & 0x00FFFFFF)
    {
      case FUNCTION:
      {

        if (!expand || !mpFunction)
          {
            out << "<mrow>" << std::endl;

            std::string Data = getData();

            if (mQuotesRequired)
              {
                Data = "\"" + quote(Data, "-+^*/%(){},\t\r\n\"") + "\"";
              }

            out << "<mi>" << CMathMl::fixName(Data) << "</mi>" << std::endl;
            out << "<mrow>" << std::endl;
            out << "<mo>(</mo>" << std::endl;
            out << "<mrow>" << std::endl;

            if (it != end)
              {
                out << *it++;
              }

            for (; it != end; ++it)
              {
                out << "<mo> , </mo>" << std::endl;
                out << *it;
              }

            out << "</mrow>" << std::endl;
            out << "<mo>) </mo>" << std::endl;

            out << "</mrow>" << std::endl;
            out << "</mrow>" << std::endl;
          }
        else
          {
            std::vector< std::vector< std::string > > Variables;

            for (; it != end; ++it)
              {
                std::vector< std::string > Variable;
                Variable.push_back(*it);
                Variables.push_back(Variable);
              }

            out << "<mfenced>" << std::endl;
            out << mpFunction->writeMathML(Variables, expand, expand);
            out << "</mfenced>" << std::endl;
          }
      }
      break;

      case EXPRESSION:
        break;

      default:
        break;
    }

  return out.str();
}

std::string CEvaluationNodeCall::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 410 of file CEvaluationNodeCall.cpp.

References CCopasiNode< std::string >::mData, mQuotesRequired, and quote().

{
  std::string DisplayString;

  if (mQuotesRequired)
    {
      DisplayString = "\"" + quote(mData, "-+^*/%(){},\t\r\n\"") + "\"(";
    }
  else
    {
      DisplayString = quote(mData, "-+^*/%(){},\t\r\n") + "(";
    }

  return DisplayString;
}

bool CEvaluationNodeCall::isBoolean ( ) const

virtual

Check whether the result is Boolean

Returns

bool isBoolean

Reimplemented from CEvaluationNode.

Definition at line 665 of file CEvaluationNodeCall.cpp.

References getCalledTree(), and CEvaluationTree::isBoolean().

{
  const CEvaluationTree * pEvaluationTree = getCalledTree();

  if (pEvaluationTree != NULL)
    {
      return pEvaluationTree->isBoolean();
    }

  return false;
}

const bool & CEvaluationNodeCall::isBooleanRequired

(

)

const

Check whether the result must be Boolean

Returns

const bool & isBooleanRequired

Definition at line 661 of file CEvaluationNodeCall.cpp.

References mBooleanRequired.

{return mBooleanRequired;}

bool CEvaluationNodeCall::removeChild ( CCopasiNode< Data > *  pChild )

virtual

Remove a child from a node.

Parameters

CCopasiNode<

Data > * pChild

Returns

bool Success

Reimplemented from CCopasiNode< std::string >.

Definition at line 490 of file CEvaluationNodeCall.cpp.

References mCallNodes, and CCopasiNode< _Data >::removeChild().

Referenced by CEvaluationNodeNormalizer::normalizeCEvaluationNodeCall().

{
  std::vector<CEvaluationNode *>::iterator it = mCallNodes.begin();
  std::vector<CEvaluationNode *>::iterator end = mCallNodes.end();

  while (it != end && *it != pChild) ++it;

  if (it != end) mCallNodes.erase(it);

  return CCopasiNode< Data >::removeChild(pChild);
}

void CEvaluationNodeCall::setBooleanRequired

(

const bool &

booleanRequired

)

Set whether the result of the node must be Boolean

Parameters

const

bool & booleanRequired

Definition at line 658 of file CEvaluationNodeCall.cpp.

References mBooleanRequired.

{mBooleanRequired = booleanRequired;}

bool CEvaluationNodeCall::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 241 of file CEvaluationNodeCall.cpp.

References CEvaluationNode::isKeyword(), CCopasiNode< std::string >::mData, mQuotesRequired, mRegisteredFunctionCN, quote(), and unQuote().

Referenced by CEvaluationNodeCall().

{
  mData = unQuote(data);

  // We force quoting if the round trip unquote, quote does not recover the original input
  if (isKeyword(mData))
    {
      mQuotesRequired = true;
    }

  if (mData != data && quote(mData) != data)
    {
      mQuotesRequired = true;
    }

  mRegisteredFunctionCN = std::string("");

  return true;
}

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

virtual

Create a new ASTNode corresponding to this choice node.

Returns

ASTNode* return a pointer to the newly created node;

Reimplemented from CEvaluationNode.

Definition at line 441 of file CEvaluationNodeCall.cpp.

References CCopasiNode< _Data >::addChild(), fatalError, CFunctionDB::findFunction(), CCopasiNode< std::string >::getChild(), getData(), CCopasiRootContainer::getFunctionList(), CFunction::getSBMLId(), CCopasiNode< _Data >::getSibling(), and CEvaluationNode::toAST().

{
  ASTNode* pNode = NULL;

  pNode = new ASTNode(AST_FUNCTION);
  const std::string funName = this->getData();
  CFunction * pFun = CCopasiRootContainer::getFunctionList()->findFunction(funName);
  assert(pFun != NULL);

  if (pFun == NULL || pFun->getSBMLId().empty()) fatalError();

  pNode->setName(pFun->getSBMLId().c_str());

  const CEvaluationNode* child = static_cast<const CEvaluationNode*>(this->getChild());

  while (child)
    {
      pNode->addChild(child->toAST(pDataModel));
      child = static_cast<const CEvaluationNode*>(child->getSibling());
    }

  return pNode;
}

bool CEvaluationNodeCall::verifyParameters ( const std::vector< CEvaluationNode * > &  vector, const CFunctionParameters &  functionParameters  )

staticprivate

Verifies that the parameters match the function parameters.

Parameters

const	std::vector<CEvaluationNode *> & vector
const	CFunctionParameters & functionParameters

Returns

bool verified

Definition at line 546 of file CEvaluationNodeCall.cpp.

References CEvaluationNode::getType(), CFunctionParameters::size(), CEvaluationNode::type(), CEvaluationNode::VECTOR, and CFunctionParameter::VFLOAT64.

Referenced by compile().

{
  if (vector.size() != functionParameters.size()) return false;

  std::vector<CEvaluationNode *>::const_iterator it = vector.begin();
  std::vector<CEvaluationNode *>::const_iterator end = vector.end();

  size_t i;

  for (i = 0; it != end; ++it, i++)
    {
      if ((type((*it)->getType()) == CEvaluationNode::VECTOR &&
           functionParameters[i]->getType() != CFunctionParameter::VFLOAT64) ||
          functionParameters[i]->getType() == CFunctionParameter::VFLOAT64)
        return false;
    }

  return true;
}

Member Data Documentation

bool CEvaluationNodeCall::mBooleanRequired

private

Definition at line 240 of file CEvaluationNodeCall.h.

Referenced by isBooleanRequired(), and setBooleanRequired().

std::vector<CEvaluationNode *> CEvaluationNodeCall::mCallNodes

private

Definition at line 237 of file CEvaluationNodeCall.h.

Referenced by addChild(), CEvaluationNodeCall(), compile(), getListOfChildNodes(), and removeChild().

CCallParameters< C_FLOAT64 >* CEvaluationNodeCall::mpCallParameters

private

Definition at line 238 of file CEvaluationNodeCall.h.

Referenced by calculate(), CEvaluationNodeCall(), and compile().

CExpression* CEvaluationNodeCall::mpExpression

private

Definition at line 236 of file CEvaluationNodeCall.h.

Referenced by calculate(), compile(), and getData().

CFunction* CEvaluationNodeCall::mpFunction

private

Definition at line 235 of file CEvaluationNodeCall.h.

Referenced by calculate(), compile(), getData(), and getMMLString().

bool CEvaluationNodeCall::mQuotesRequired

mutableprivate

Definition at line 239 of file CEvaluationNodeCall.h.

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

CRegisteredObjectName CEvaluationNodeCall::mRegisteredFunctionCN

private

The registered object name to track eventual renaming.

Definition at line 245 of file CEvaluationNodeCall.h.

Referenced by compile(), and setData().

---

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

• CEvaluationNodeCall.h
• CEvaluationNodeCall.cpp