void CModelExpansion::duplicateEvent(CEvent* source, const std::string & index, const SetOfModelElements & sourceSet, ElementsMap & emap)
{
//if the source object has already been duplicated: do nothing
if (emap.exists(source))
return;
CEvent* newObj = NULL;
if (expressionContainsObject(source->getTriggerExpressionPtr(), sourceSet)
|| expressionContainsObject(source->getDelayExpressionPtr(), sourceSet))
{
//we need to duplicate the event itself (because the trigger refers to a duplicated object)
//try creating the object until we find a name that is not yet used
std::ostringstream infix;
do
{
std::ostringstream name;
name << source->getObjectName() << infix.str() << index;
newObj = mpModel->createEvent(name.str());
infix << "_";
}
while (!newObj);
//add duplicated object to the map
emap.add(source, newObj);
//now do the trigger
newObj->setTriggerExpression(source->getTriggerExpression());
newObj->getTriggerExpressionPtr()->compile(); //I don't know why this is necessary
updateExpression(newObj->getTriggerExpressionPtr(), index, sourceSet, emap);
//delay
newObj->setDelayExpression(source->getDelayExpression());
newObj->getDelayExpressionPtr()->compile(); //I don't know why this is necessary
updateExpression(newObj->getDelayExpressionPtr(), index, sourceSet, emap);
newObj->setDelayAssignment(source->getDelayAssignment());
}
else
{
newObj = source; //no copying necessary
//add duplicated object to the map
emap.add(source, newObj);
}
//now the event assignments...
size_t i;
for (i = 0; i < source->getAssignments().size(); ++i)
{
const CEventAssignment* pSourceAssignment = source->getAssignments()[i];
//const CModelEntity * pSourceTarget = dynamic_cast<const CModelEntity * >(CCopasiRootContainer::getKeyFactory()->get(pSourceAssignment->getTargetKey()));
if (sourceSet.contains(pSourceAssignment->getTargetKey()))
{
//we assume that the duplicate of the target object already exists.
//this should be true since events are duplicated last.
if (!emap.exists(pSourceAssignment->getTargetKey()))
continue;
//create duplicate of assignment (this can be either in the original event or in the
//duplicate of an event)
CEventAssignment * pNewAssignment = new CEventAssignment(emap.getDuplicateKey(pSourceAssignment->getTargetKey()));
newObj->getAssignments().add(pNewAssignment, true);
//we do an assumption:
//It should not happen that the assignment expression contains a reference to an object that is duplicated,
//but the assignment target is not duplicated.
//now copy the expression
pNewAssignment->setExpression(pSourceAssignment->getExpression());
pNewAssignment->getExpressionPtr()->compile();
updateExpression(pNewAssignment->getExpressionPtr(), index, sourceSet, emap);
}
}
newObj->setNotes(source->getNotes());
newObj->setMiriamAnnotation(source->getMiriamAnnotation(), newObj->getKey(), source->getKey());
}
bool CModelAdd::addEvents(std::string name)
{
bool info = false;
size_t i, imax = mmModel->getEvents().size();
for (i = 0; i < imax; ++i)
{
const CEvent* sourceEvent = &mmModel->getEvents()[i];
if (!sourceEvent) return info;
//create new event
std::string eventName;
eventName = sourceEvent->getObjectName();
std::string appendix = "";
#if 0
unsigned int counter = 2;
std::ostringstream numberStream;
while (mpModel->getEvents().getIndex(eventName + appendix) != C_INVALID_INDEX)
{
numberStream.str("");
numberStream << "_" << counter;
counter++;
appendix = numberStream.str();
}
#else
appendix = "_" + name;
#endif
CEvent* newEvent = mpModel->createEvent(eventName + appendix);
if (newEvent == NULL) return info;
/* copy trigger expression */
if (sourceEvent->getTriggerExpressionPtr() != NULL)
{
if (!copyTriggerExpression(sourceEvent, newEvent))
return info;
}
else
{
return info;
}
/* set whether the calculation or the assignment shall be delayed */
newEvent->setDelayAssignment(sourceEvent->getDelayAssignment());
/* copy the delay expression */
if (sourceEvent->getDelayExpressionPtr() != NULL)
if (!copyDelayExpression(sourceEvent, newEvent)) return info;
/* copy the assignments */
size_t j, jmax = sourceEvent->getAssignments().size();
for (j = 0; j < jmax; ++j)
{
const CEventAssignment* sourceAssignment = &sourceEvent->getAssignments()[j];
if (!sourceAssignment) return info;
std::string key = sourceAssignment->getTargetKey();
CEventAssignment* newAssignment = new CEventAssignment;
newEvent->getAssignments().add(newAssignment, true);
newAssignment->setTargetKey(keyMap[key]);
if (sourceAssignment->getExpressionPtr() != NULL)
{
if (!copyEventAssignmentExpression(sourceAssignment, newAssignment))
return info;
}
else
{
return info;
}
}
}
return true;
}
