CCopasiXMLParser::FunctionElement Class Reference

Inheritance diagram for CCopasiXMLParser::FunctionElement:

Collaboration diagram for CCopasiXMLParser::FunctionElement:

Public Member Functions
virtual void	end (const XML_Char *pszName)
	FunctionElement (CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void	start (const XML_Char *pszName, const XML_Char **papszAttrs)
virtual	~FunctionElement ()
Public Member Functions inherited from CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
	CXMLElementHandler (CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void	end (const XML_Char *C_UNUSED(pszName))
virtual void	reset ()
virtual void	start (const XML_Char *C_UNUSED(pszName), const XML_Char **C_UNUSED(papszAttrs))
virtual	~CXMLElementHandler ()

Private Types
enum	Element {   Function = 0, MiriamAnnotation, Comment, ListOfUnsupportedAnnotations,   Expression, ListOfParameterDescriptions, MathML }

Private Attributes
std::set< size_t >	mExistingFunctionIndex
std::string	mKey
ListOfParameterDescriptionsElement *	mpListOfParameterDescriptionsElement
MathMLElement *	mpMathMLElement

Additional Inherited Members
Protected Member Functions inherited from CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
void	addFix (const std::string &key, CCopasiObject *pObject)
void	deleteCurrentHandler ()
Protected Attributes inherited from CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
SCopasiXMLParserCommon &	mCommon
C_INT32	mCurrentElement
C_INT32	mLastKnownElement
CCopasiXMLParser &	mParser
CXMLElementHandler *	mpCurrentHandler

Detailed Description

Definition at line 3033 of file CCopasiXMLParser.h.

Member Enumeration Documentation

enum CCopasiXMLParser::FunctionElement::Element

private

Enumerator
Function
MiriamAnnotation
Comment
ListOfUnsupportedAnnotations
Expression
ListOfParameterDescriptions
MathML

Definition at line 3040 of file CCopasiXMLParser.h.

    {
      Function = 0,
      MiriamAnnotation,
      Comment,
      ListOfUnsupportedAnnotations,
      Expression,
      ListOfParameterDescriptions,
      MathML
    };

Constructor & Destructor Documentation

CCopasiXMLParser::FunctionElement::FunctionElement	(	CCopasiXMLParser &	parser,
		SCopasiXMLParserCommon &	common
	)

Constructor

Definition at line 757 of file CCopasiXMLParser.cpp.

                                    :
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mpMathMLElement(NULL),
  mpListOfParameterDescriptionsElement(NULL)
{}

CCopasiXMLParser::FunctionElement::~FunctionElement ( )

virtual

Destructor

Definition at line 764 of file CCopasiXMLParser.cpp.

References pdelete.

{
  pdelete(mpMathMLElement);
  pdelete(mpListOfParameterDescriptionsElement);
}

Member Function Documentation

void CCopasiXMLParser::FunctionElement::end ( const XML_Char *  pszName )

virtual

End element handler

Parameters

const

XML_Char *pszName

Definition at line 1011 of file CCopasiXMLParser.cpp.

References CCopasiVectorN< CType >::add(), SCopasiXMLParserCommon::CharacterData, CCopasiMessage::EXCEPTION, CFunction::getKey(), CAnnotation::getUnsupportedAnnotations(), CFunction::getVariables(), CCopasiXMLParser::mCommon, MCXML, SCopasiXMLParserCommon::mFunctionParameterKeyMap, CExpatTemplate< CExpat >::mParser, SCopasiXMLParserCommon::mpExpression, SCopasiXMLParserCommon::mPredefinedFunction, pdelete, SCopasiXMLParserCommon::pFunction, SCopasiXMLParserCommon::pFunctionList, CFunction::setInfix(), CExpression::setInfix(), CAnnotation::setMiriamAnnotation(), CAnnotation::setNotes(), START_ELEMENT, and UNKNOWN_ELEMENT.

{
  switch (mCurrentElement)
    {
      case Function:

        if (strcmp(pszName, "Function"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Function", mParser.getCurrentLineNumber());

        mLastKnownElement = START_ELEMENT;
        mParser.popElementHandler();

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);

        if (mCommon.pFunction != NULL)
          {
            if (!mCommon.mPredefinedFunction)
              {
                // TODOWe need to check whether any existing function with the same
                // name is identical

                std::set< size_t >::const_iterator it = mExistingFunctionIndex.begin();
                std::set< size_t >::const_iterator end = mExistingFunctionIndex.end();

                for (; it != end; ++it)
                  {
                    CFunction * pFunction = (*mCommon.pFunctionList)[*it];

                    if (*pFunction == *mCommon.pFunction)
                      {
                        pdelete(mCommon.pFunction);
                        mCommon.pFunction = (*mCommon.pFunctionList)[*it];

                        break;
                      }
                  }

                /* We have a new function and add it to the list */
                if (it == end)
                  {
                    mCommon.pFunctionList->add(mCommon.pFunction, true);
                  }
              }

            addFix(mKey , mCommon.pFunction);

            std::map< size_t, std::string >::const_iterator it = mCommon.mFunctionParameterKeyMap.begin();
            std::map< size_t, std::string >::const_iterator end = mCommon.mFunctionParameterKeyMap.end();

            for (; it != end; ++it)
              {
                addFix(it->second, mCommon.pFunction->getVariables()[it->first]);
              }
          }

        break;

      case MiriamAnnotation:

        if (strcmp(pszName, "MiriamAnnotation"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MiriamAnnotation", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            mCommon.pFunction->setMiriamAnnotation(mCommon.CharacterData, mCommon.pFunction->getKey(), mKey);
            mCommon.CharacterData = "";
          }

        break;

      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            mCommon.pFunction->setNotes(mCommon.CharacterData);
            mCommon.CharacterData = "";
          }

        break;

      case ListOfUnsupportedAnnotations:

        if (strcmp(pszName, "ListOfUnsupportedAnnotations"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfUnsupportedAnnotations", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            mCommon.pFunction->getUnsupportedAnnotations() = mParser.mListOfUnsupportedAnnotationsElement.getUnsupportedAnnotations();
          }

        break;

      case Expression:

        if (strcmp(pszName, "Expression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Expression", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            if (!mCommon.mPredefinedFunction)
              {
                // do not yet compile the function as it might depend on elements not
                // read yet
                mCommon.pFunction->setInfix(mCommon.CharacterData, false);
              }
          }
        else if (mCommon.mpExpression != NULL)
          {
            mCommon.mpExpression->setInfix(mCommon.CharacterData);
          }

        break;

      case ListOfParameterDescriptions:

        if (strcmp(pszName, "ListOfParameterDescriptions"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfParameterDescriptions", mParser.getCurrentLineNumber());

        break;

      case MathML:

        if (strcmp(pszName, "MathML"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MathML", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            if (!mCommon.mPredefinedFunction)
              mCommon.pFunction->setInfix(mCommon.CharacterData);
          }
        else if (mCommon.mpExpression != NULL)
          {
            mCommon.mpExpression->setInfix(mCommon.CharacterData);
          }

        // MathML is in place of Expression in old CopasiML files.
        mLastKnownElement = Expression;
        break;

      case UNKNOWN_ELEMENT:
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  mCurrentElement = Function;

  return;
}

void CCopasiXMLParser::FunctionElement::start ( const XML_Char *  pszName, const XML_Char **  papszAttrs  )

virtual

Start element handler

Parameters

const	XML_Char *pszName
const	XML_Char **papszAttrs

Definition at line 770 of file CCopasiXMLParser.cpp.

References C_INVALID_INDEX, CEvaluationTree::create(), CCopasiMessage::EXCEPTION, CEvaluationTree::Expression, CEvaluationTree::Function, CCopasiVectorN< CType >::getIndex(), CEvaluationTree::MassAction, CCopasiXMLParser::mCommon, MCXML, SCopasiXMLParserCommon::mFunctionParameterKeyMap, SCopasiXMLParserCommon::mKey2ObjectiveFunction, CExpatTemplate< CExpat >::mParser, SCopasiXMLParserCommon::mpExpression, SCopasiXMLParserCommon::mPredefinedFunction, pdelete, SCopasiXMLParserCommon::pFunction, SCopasiXMLParserCommon::pFunctionList, CEvaluationTree::PreDefined, CCopasiObject::setObjectName(), CFunction::setReversible(), toEnum(), TriFalse, TriTrue, TriUnspecified, UNKNOWN_ELEMENT, CEvaluationTree::UserDefined, and CEvaluationTree::XMLType.

{
  const char * type;
  CEvaluationTree::Type Type;
  const char * Name;
  const char * Reversible;
  size_t Index;

  mpCurrentHandler = NULL;
  mCurrentElement = mLastKnownElement;

  while (mpCurrentHandler == NULL)
    {
      mCurrentElement++; /* We should always be on the next element */
      CEvaluationTree* pEvaluationTree = NULL;

      switch (mCurrentElement)
        {
          case Function:

            if (strcmp(pszName, "Function"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "Function", mParser.getCurrentLineNumber());

            mKey = mParser.getAttributeValue("key", papszAttrs);
            Name = mParser.getAttributeValue("name", papszAttrs);
            type = mParser.getAttributeValue("type", papszAttrs);
            Type = toEnum(type, CEvaluationTree::XMLType, CEvaluationTree::UserDefined);

            Reversible = mParser.getAttributeValue("reversible", papszAttrs, false);

            if (!Reversible) // We may have an old file format using positive
              Reversible = mParser.getAttributeValue("positive", papszAttrs, "unspecified");

            mLastKnownElement = Function;

            mCommon.mPredefinedFunction = false;
            mCommon.mFunctionParameterKeyMap.clear();
            mExistingFunctionIndex.clear();

            pEvaluationTree = CEvaluationTree::create(Type);

            if (Type == CEvaluationTree::Expression)
              {
                mCommon.pFunction = NULL;

                mCommon.mpExpression = static_cast< CExpression * >(pEvaluationTree);
                mCommon.mKey2ObjectiveFunction[mKey] = mCommon.mpExpression;
              }
            else
              {
                mCommon.mpExpression = NULL;

                mCommon.pFunction = static_cast<CFunction *>(pEvaluationTree);
                mCommon.pFunction->setObjectName(Name);

                if (!strcmp(Reversible, "true"))
                  mCommon.pFunction->setReversible(TriTrue);
                else if (!strcmp(Reversible, "false"))
                  mCommon.pFunction->setReversible(TriFalse);
                else
                  mCommon.pFunction->setReversible(TriUnspecified);

                Index = mCommon.pFunctionList->getIndex(Name);

                if (Index != C_INVALID_INDEX) // A function with that name exists.
                  {
                    mExistingFunctionIndex.insert(Index);

                    switch ((*mCommon.pFunctionList)[Index]->getType())
                      {
                        case CEvaluationTree::MassAction:

                          if (Type == CEvaluationTree::MassAction)
                            {
                              pdelete(mCommon.pFunction);
                              mCommon.pFunction = (*mCommon.pFunctionList)[Index];
                              mCommon.mPredefinedFunction = true;
                            }
                          else
                            {
                              size_t Counter = 0;
                              std::string NewName;

                              while (true)
                                {
                                  Counter++;
                                  std::ostringstream ss;
                                  ss << Name << " [" << Counter << "]";
                                  NewName = ss.str();
                                  Index = mCommon.pFunctionList->getIndex(NewName);

                                  if (Index == C_INVALID_INDEX)
                                    break;

                                  mExistingFunctionIndex.insert(Index);
                                }

                              mCommon.pFunction->setObjectName(NewName);
                            }

                          break;

                        case CEvaluationTree::PreDefined:

                          if (Type == CEvaluationTree::PreDefined)
                            {
                              pdelete(mCommon.pFunction);
                              mCommon.pFunction = (*mCommon.pFunctionList)[Index];
                              mCommon.mPredefinedFunction = true;
                            }
                          else
                            {
                              size_t Counter = 0;
                              std::string NewName;

                              while (true)
                                {
                                  Counter++;
                                  std::ostringstream ss;
                                  ss << Name << " [" << Counter << "]";
                                  NewName = ss.str();
                                  Index = mCommon.pFunctionList->getIndex(NewName);

                                  if (Index == C_INVALID_INDEX)
                                    break;

                                  mExistingFunctionIndex.insert(Index);
                                }

                              mCommon.pFunction->setObjectName(NewName);
                            }

                          break;

                        case CEvaluationTree::UserDefined:
                        case CEvaluationTree::Function:
                          // Create a unique name
                        {
                          size_t Counter = 0;
                          std::string NewName;

                          while (true)
                            {
                              Counter++;
                              std::ostringstream ss;
                              ss << Name << " [" << Counter << "]";
                              NewName = ss.str();
                              Index = mCommon.pFunctionList->getIndex(NewName);

                              if (Index == C_INVALID_INDEX)
                                break;

                              mExistingFunctionIndex.insert(Index);
                            }

                          mCommon.pFunction->setObjectName(NewName);
                        }

                        break;

                        default:
                          break;
                      }
                  }
              }

            return;

          case MiriamAnnotation:

            if (!strcmp(pszName, "MiriamAnnotation"))
              mpCurrentHandler = &mParser.mMiriamAnnotationElement;

            break;

          case Comment:

            if (!strcmp(pszName, "Comment"))
              mpCurrentHandler = &mParser.mCommentElement;

            break;

          case ListOfUnsupportedAnnotations:

            if (!strcmp(pszName, "ListOfUnsupportedAnnotations"))
              mpCurrentHandler = &mParser.mListOfUnsupportedAnnotationsElement;

            break;

          case Expression:

            if (!strcmp(pszName, "Expression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;
            else if (!strcmp(pszName, "MathML"))
              {
                /* If we do not have a MathML element handler we create one. */
                if (!mpMathMLElement)
                  mpMathMLElement = new MathMLElement(mParser, mCommon);

                mCurrentElement = MathML;
                mpCurrentHandler = mpMathMLElement;
              }
            else
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "Expression", mParser.getCurrentLineNumber());

            break;

          case ListOfParameterDescriptions:

            if (strcmp(pszName, "ListOfParameterDescriptions"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "ListOfParameterDescriptions", mParser.getCurrentLineNumber());

            /* If we do not have a ListOfParameterDescriptions element handler we create one. */
            if (!mpListOfParameterDescriptionsElement)
              mpListOfParameterDescriptionsElement = new ListOfParameterDescriptionsElement(mParser, mCommon);

            /* Push the ListOfParameterDescriptions element handler on the stack and call it. */
            mpCurrentHandler = mpListOfParameterDescriptionsElement;
            break;

          default:
            mCurrentElement = UNKNOWN_ELEMENT;
            mpCurrentHandler = &mParser.mUnknownElement;
            break;
        }
    }

  mParser.pushElementHandler(mpCurrentHandler);

  if (mpCurrentHandler != &mParser.mUnknownElement)
    {
      mLastKnownElement = mCurrentElement;
    }

  mParser.onStartElement(pszName, papszAttrs);
}

Member Data Documentation

std::set< size_t > CCopasiXMLParser::FunctionElement::mExistingFunctionIndex

private

The index of a function with the same name

Definition at line 3069 of file CCopasiXMLParser.h.

std::string CCopasiXMLParser::FunctionElement::mKey

private

The key in the CopasiML file

Definition at line 3064 of file CCopasiXMLParser.h.

ListOfParameterDescriptionsElement* CCopasiXMLParser::FunctionElement::mpListOfParameterDescriptionsElement

private

Definition at line 3059 of file CCopasiXMLParser.h.

MathMLElement* CCopasiXMLParser::FunctionElement::mpMathMLElement

private

Definition at line 3054 of file CCopasiXMLParser.h.

---

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

• CCopasiXMLParser.h
• CCopasiXMLParser.cpp