#include <CModelExpansion.h>

Collaboration diagram for CModelExpansion::SetOfModelElements:

Public Member Functions
void	addCompartment (const CCompartment *x)

void	addEvent (const CEvent *x)

void	addGlobalQuantity (const CModelValue *x)

void	addMetab (const CMetab *x)

bool	addObject (const CCopasiObject *x)

void	addReaction (const CReaction *x)

bool	contains (const CCopasiObject *x) const

bool	contains (const std::string &key) const

void	fillComplete (const CModel *pModel)

void	fillDependencies (const CModel *pModel)

Public Attributes
std::set< const CCompartment * >	mCompartments

std::set< const CEvent * >	mEvents

std::set< const CModelValue * >	mGlobalQuantities

std::set< const CMetab * >	mMetabs

std::set< const CReaction * >	mReactions

Detailed Description

This class describes a set of model elements that are supposed to be duplicated. The second element in each of the pairs is used temporarily to hold the copy.

Definition at line 50 of file CModelExpansion.h.

Member Function Documentation

void CModelExpansion::SetOfModelElements::addCompartment ( const CCompartment * x )

Definition at line 21 of file CModelExpansion.cpp.

References mCompartments.

Referenced by CQSpeciesDetail::copy(), ReactionsWidget1::copy(), CModelExpansion::simpleCall(), and CQExpandModelData::slotOK().

 {
   mCompartments.insert(x);
 }

void CModelExpansion::SetOfModelElements::addEvent ( const CEvent * x )

Definition at line 41 of file CModelExpansion.cpp.

 {
   mEvents.insert(x);
 }

void CModelExpansion::SetOfModelElements::addGlobalQuantity ( const CModelValue * x )

Definition at line 36 of file CModelExpansion.cpp.

 {
   mGlobalQuantities.insert(x);
 }

void CModelExpansion::SetOfModelElements::addMetab ( const CMetab * x )

Definition at line 26 of file CModelExpansion.cpp.

Referenced by CQSpeciesDetail::copy(), CQCompartment::copy(), and ReactionsWidget1::copy().

 {
   mMetabs.insert(x);
 }

bool CModelExpansion::SetOfModelElements::addObject ( const CCopasiObject * x )

Definition at line 46 of file CModelExpansion.cpp.

Referenced by CQCompartment::copy(), and CModelExpansion::existDependentEntities().

 {
   if (dynamic_cast<const CCompartment*>(x))
     {
       addCompartment(dynamic_cast<const CCompartment*>(x));
       return true;
     }
 
   if (dynamic_cast<const CMetab*>(x))
     {
       addMetab(dynamic_cast<const CMetab*>(x));
       return true;
     }
 
   if (dynamic_cast<const CReaction*>(x))
     {
       addReaction(dynamic_cast<const CReaction*>(x));
       return true;
     }
 
   if (dynamic_cast<const CModelValue*>(x))
     {
       addGlobalQuantity(dynamic_cast<const CModelValue*>(x));
       return true;
     }
 
   if (dynamic_cast<const CEvent*>(x))
     {
       addEvent(dynamic_cast<const CEvent*>(x));
       return true;
     }
 
   return false;
 }

void CModelExpansion::SetOfModelElements::addReaction ( const CReaction * x )

Definition at line 31 of file CModelExpansion.cpp.

Referenced by CQCompartment::copy(), and ReactionsWidget1::copy().

 {
   mReactions.insert(x);
 }

bool CModelExpansion::SetOfModelElements::contains ( const CCopasiObject * x ) const

Checks whether an object is present in this set

Definition at line 81 of file CModelExpansion.cpp.

Referenced by CModelExpansion::duplicateEvent(), CModelExpansion::duplicateMetab(), CModelExpansion::duplicateReaction(), CModelExpansion::expressionContainsObject(), and CModelExpansion::updateExpression().

 {
   if (mCompartments.find(static_cast<const CCompartment*>(x)) != mCompartments.end())
     return true;
 
   if (mMetabs.find(static_cast<const CMetab*>(x)) != mMetabs.end())
     return true;
 
   if (mReactions.find(static_cast<const CReaction*>(x)) != mReactions.end())
     return true;
 
   if (mGlobalQuantities.find(static_cast<const CModelValue*>(x)) != mGlobalQuantities.end())
     return true;
 
   if (mEvents.find(static_cast<const CEvent*>(x)) != mEvents.end())
     return true;
 
   return false;
 }

bool CModelExpansion::SetOfModelElements::contains ( const std::string & key ) const

Definition at line 101 of file CModelExpansion.cpp.

References CKeyFactory::get(), and CCopasiRootContainer::getKeyFactory().

 {
   const CCopasiObject* tmp = CCopasiRootContainer::getKeyFactory()->get(key);
 
   if (tmp)
     return contains(tmp);
   else
     return false;
 }

void CModelExpansion::SetOfModelElements::fillComplete ( const CModel * pModel )

enters all the objects from pModel

Definition at line 184 of file CModelExpansion.cpp.

References CModel::getCompartments(), CModel::getEvents(), CModel::getMetabolites(), CModel::getModelValues(), CModel::getReactions(), and CCopasiVector< T >::size().

Referenced by CModelExpansion::copyCompleteModel().

 {
   if (!pModel)
     return;
 
   size_t i;
 
   for (i = 0; i < pModel->getCompartments().size(); ++i)
     addCompartment(pModel->getCompartments()[i]);
 
   for (i = 0; i < pModel->getMetabolites().size(); ++i)
     addMetab(pModel->getMetabolites()[i]);
 
   for (i = 0; i < pModel->getReactions().size(); ++i)
     addReaction(pModel->getReactions()[i]);
 
   for (i = 0; i < pModel->getModelValues().size(); ++i)
     addGlobalQuantity(pModel->getModelValues()[i]);
 
   for (i = 0; i < pModel->getEvents().size(); ++i)
     addEvent(pModel->getEvents()[i]);
 }

void CModelExpansion::SetOfModelElements::fillDependencies ( const CModel * pModel )

Determines which other object have to be duplicated based on those already present.

Definition at line 111 of file CModelExpansion.cpp.

References CModel::appendDependentModelObjects().

Referenced by CQCompartment::copy(), CModelExpansion::existDependentEntities(), CModelExpansion::simpleCall(), and CQExpandModelData::slotOK().

 {
   if (!pModel) return;
 
   //create a combined set of all elements we know are to be copied
   std::set< const CCopasiObject * > combinedSet;
 
   std::set<const CCompartment*>::const_iterator itComp;
 
   for (itComp = mCompartments.begin(); itComp != mCompartments.end(); ++itComp)
     {
       std::set< const CCopasiObject * > tmp = (*itComp)->getDeletedObjects();
       combinedSet.insert(tmp.begin(), tmp.end());
     }
 
   std::set<const CMetab*>::const_iterator itMetab;
 
   for (itMetab = mMetabs.begin(); itMetab != mMetabs.end(); ++itMetab)
     {
       std::set< const CCopasiObject * > tmp = (*itMetab)->getDeletedObjects();
       combinedSet.insert(tmp.begin(), tmp.end());
     }
 
   std::set<const CReaction*>::const_iterator itReac;
 
   for (itReac = mReactions.begin(); itReac != mReactions.end(); ++itReac)
     {
       std::set< const CCopasiObject * > tmp = (*itReac)->getDeletedObjects();
       combinedSet.insert(tmp.begin(), tmp.end());
     }
 
   std::set<const CModelValue*>::const_iterator itQuant;
 
   for (itQuant = mGlobalQuantities.begin(); itQuant != mGlobalQuantities.end(); ++itQuant)
     {
       std::set< const CCopasiObject * > tmp = (*itQuant)->getDeletedObjects();
       combinedSet.insert(tmp.begin(), tmp.end());
     }
 
   /* Events do not contain any relevant objects.
   std::set<const CEvent*>::const_iterator itEvent;
 
   for (itEvent = mEvents.begin(); itEvent != mEvents.end(); ++itEvent)
     {
       std::set< const CCopasiObject * > tmp = (*itEvent)->getDeletedObjects();
       combinedSet.insert(tmp.begin(), tmp.end());
     }
   */
 
   //ask the model for the dependencies
 
   std::set< const CCopasiObject * > reacs, metabs, comps, values, events;
   pModel->appendDependentModelObjects(combinedSet, reacs, metabs, comps, values, events);
 
   //incorporate the results into the local sets
   std::set< const CCopasiObject * >::const_iterator it;
 
   for (it = reacs.begin(); it != reacs.end(); ++it)
     addReaction(dynamic_cast<const CReaction*>(*it));
 
   for (it = metabs.begin(); it != metabs.end(); ++it)
     addMetab(dynamic_cast<const CMetab*>(*it));
 
   for (it = comps.begin(); it != comps.end(); ++it)
     addCompartment(dynamic_cast<const CCompartment*>(*it));
 
   for (it = values.begin(); it != values.end(); ++it)
     addGlobalQuantity(dynamic_cast<const CModelValue*>(*it));
 
   for (it = events.begin(); it != events.end(); ++it)
     addEvent(dynamic_cast<const CEvent*>(*it));
 }