Loop node for parametric calculation. More...

#include <ForEachLoop.hxx>

Inheritance diagram for YACS::ENGINE::ForEachLoop:

Collaboration diagram for YACS::ENGINE::ForEachLoop:

Public Member Functions
	ForEachLoop (const std::string &name, TypeCode *typeOfDataSplitted)

	ForEachLoop (const ForEachLoop &other, ComposedNode *father, bool editionOnly)

	~ForEachLoop ()

void	init (bool start=true)

void	exUpdateState ()
	Update the node state. More...

void	exUpdateProgress ()

void	getReadyTasks (std::vector< Task * > &tasks)

int	getNumberOfInputPorts () const

void	checkNoCyclePassingThrough (Node *node) throw (Exception)

void	selectRunnableTasks (std::vector< Task * > &tasks)

unsigned	getExecCurrentId () const

std::list< InputPort * >	getSetOfInputPort () const

std::list< InputPort * >	getLocalInputPorts () const
	redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself More...

InputPort *	edGetSeqOfSamplesPort ()

InputPort *	getInputPort (const std::string &name) const throw (Exception)
	Get an input port given its name. More...

OutPort *	getOutPort (const std::string &name) const throw (Exception)

OutputPort *	getOutputPort (const std::string &name) const throw (Exception)
	Get an output port given its name. More...

Node *	getChildByShortName (const std::string &name) const throw (Exception)

std::list< OutputPort * >	getLocalOutputPorts () const
	redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself More...

void	accept (Visitor *visitor)

void	writeDot (std::ostream &os) const
	Dump the node state to a stream. More...

virtual std::string	typeName ()

virtual void	resetState (int level)
	Reset the state of the node and its children depending on the parameter level. More...

std::string	getProgress () const

std::list< ProgressWeight >	getProgressWeight () const
	Get the progress weight for all elementary nodes. More...

int	getCurrentIndex () const

int	getNbOfElementsToBeProcessed () const

ForEachLoopPassedData *	getProcessedData () const

void	setProcessedData (ForEachLoopPassedData *processedData)

std::vector< unsigned int >	getPassedResults (Executor execut, std::vector< SequenceAny > &outputs, std::vector< std::string > &nameOfOutputs) const

void	assignPassedResults (const std::vector< unsigned int > &passedIds, const std::vector< SequenceAny * > &passedOutputs, const std::vector< std::string > &nameOfOutputs)

const TypeCode *	getOutputPortType (const std::string &portName) const

Public Member Functions inherited from YACS::ENGINE::DynParaLoop
Node *	edRemoveNode ()

Node *	edRemoveInitNode ()

Node *	edRemoveFinalizeNode ()

Node *	edSetNode (Node *DISOWNnode)

Node *	edSetInitNode (Node *DISOWNnode)

Node *	edSetFinalizeNode (Node *DISOWNnode)

virtual bool	edAddDFLink (OutPort start, InPort end) throw (Exception)
	Connect an OutPort to an InPort and add control link if necessary. More...

InputPort *	edGetNbOfBranchesPort ()

int	getNumberOfOutputPorts () const

unsigned	getNumberOfEltsConsumed () const

int	getBranchIDOfNode (Node *node) const

std::list< OutputPort * >	getSetOfOutputPort () const

OutputPort *	edGetSamplePort ()

bool	isPlacementPredictableB4Run () const
	For the moment false is returned : impovement about it coming soon. More...

void	edRemoveChild (Node *node) throw (Exception)
	Remove a child node. More...

virtual bool	edAddChild (Node *DISOWNnode) throw (Exception)

std::list< Node * >	edGetDirectDescendants () const

unsigned	getNumberOfBranchesCreatedDyn () const throw (Exception)

Node *	getChildByNameExec (const std::string &name, unsigned id) const throw (Exception)

std::vector< Node * >	getNodes () const

bool	isMultiplicitySpecified (unsigned &value) const

void	forceMultiplicity (unsigned value)

virtual void	checkBasicConsistency () const throw (Exception)

virtual std::string	getErrorReport ()
	returns a string that contains an error report if the node is in error More...

Node *	getInitNode ()

Node *	getExecNode ()

Node *	getFinalizeNode ()

int	getMaxLevelOfParallelism () const

Public Member Functions inherited from YACS::ENGINE::ComposedNode
virtual	~ComposedNode ()

bool	isFinished ()

std::string	getName () const

std::string	getTaskName (Task *task) const

DeploymentTree	getDeploymentTree () const
	Essentially for test. Use checkDeploymentTree instead to be sure that returned DeploymentTree is consistent. More...

DeploymentTree	checkDeploymentTree (bool deep) const throw (Exception)
	Perform check of deployment consistency of the current graph. More...

std::vector< Task * >	getNextTasks (bool &isMore)

void	notifyFrom (const Task sender, YACS::Event event, const Executor execInst)
	Notify the node a task has emitted an event. More...

bool	edAddLink (OutPort start, InPort end) throw (Exception)
	Add a dataflow link between two data ports. More...

bool	edAddLink (OutGate start, InGate end) throw (Exception)
	Add a controlflow link between two control ports. More...

bool	edAddCFLink (Node nodeS, Node nodeE) throw (Exception)
	Add a controlflow link between two nodes. More...

void	edRemoveCFLink (Node nodeS, Node nodeE) throw (Exception)
	Remove a controlflow link. More...

void	edRemoveLink (OutPort start, InPort end) throw (Exception)
	Remove a dataflow link. More...

void	edRemoveLink (OutGate start, InGate end) throw (Exception)
	Remove a controlflow link. More...

virtual bool	isRepeatedUnpredictablySeveralTimes () const

virtual void	removeRecursivelyRedundantCL ()

std::list< ElementaryNode * >	getRecursiveConstituents () const

std::list< Node * >	getAllRecursiveNodes ()
	Get all children nodes elementary and composed including this node. More...

virtual std::list< Node * >	getAllRecursiveConstituents ()
	Idem getAllRecursiveNodes, but this node is NOT included. More...

std::string	getInPortName (const InPort *) const throw (Exception)
	Get the input port name. More...

std::string	getOutPortName (const OutPort *) const throw (Exception)

std::set< OutPort * >	getAllOutPortsLeavingCurrentScope () const
	List all output ports of children nodes that are linked to out of scope input ports. More...

std::set< InPort * >	getAllInPortsComingFromOutsideOfCurrentScope () const
	List all input ports that are linked to out of scope ports. More...

std::list< InputDataStreamPort * >	getSetOfInputDataStreamPort () const

std::list< OutputDataStreamPort * >	getSetOfOutputDataStreamPort () const

InputDataStreamPort *	getInputDataStreamPort (const std::string &name) const throw (Exception)

OutputDataStreamPort *	getOutputDataStreamPort (const std::string &name) const throw (Exception)

std::vector< std::pair < OutPort , InPort > >	getSetOfInternalLinks () const

virtual std::vector< std::pair < OutPort , InPort > >	getSetOfLinksLeavingCurrentScope () const

void	checkConsistency (LinkInfo &info) const throw (Exception)

virtual std::vector< std::pair < InPort , OutPort > >	getSetOfLinksComingInCurrentScope () const

virtual void	edUpdateState ()
	update the status of the node More...

ComposedNode *	getRootNode () const throw (Exception)

bool	isNodeAlreadyAggregated (const Node *node) const
	Check that Node 'node' is already a direct son of this. More...

virtual bool	isNameAlreadyUsed (const std::string &name) const

Node *	isInMyDescendance (Node *nodeToTest) const
	Returns the parent of a node that is the direct child of this node. More...

std::string	getChildName (const Node *node) const throw (Exception)

virtual std::string	getMyQualifiedName (const Node *directSon) const

Node *	getChildByName (const std::string &name) const throw (Exception)

void	loaded ()

void	connected ()

virtual void	cleanNodes ()
	Clean the composed node in case of not clean exit. More...

Public Member Functions inherited from YACS::ENGINE::Node
virtual	~Node ()

Node *	clone (ComposedNode *father, bool editionOnly=true) const
	This method MUST NEVER BE VIRTUAL More...

Node *	cloneWithoutCompAndContDeepCpy (ComposedNode *father, bool editionOnly=true) const
	This method MUST NEVER BE VIRTUAL More...

void	setState (YACS::StatesForNode theState)
	Sets the given state for node. More...

virtual YACS::StatesForNode	getState () const

virtual YACS::StatesForNode	getEffectiveState () const
	Return the node state in the context of its father. More...

virtual YACS::StatesForNode	getEffectiveState (const Node *) const
	Return the effective state of a node in the context of this one (its father) More...

std::string	getColorState (YACS::StatesForNode state) const
	Return the color associated to a state. More...

InGate *	getInGate ()

OutGate *	getOutGate ()

const std::string &	getName () const

void	setName (const std::string &name)
	Change the name of the node. More...

ComposedNode *	getFather () const

const std::string	getId () const

bool	exIsControlReady () const

std::list< Node * >	getOutNodes () const

virtual void	exFailedState ()
	Notify this node that its execution has failed. More...

virtual void	exDisabledState ()
	Notify this node that it has been disabled. More...

std::list< InPort * >	getSetOfInPort () const

std::list< OutPort * >	getSetOfOutPort () const

virtual std::set< InputPort * >	edGetSetOfUnitializedInputPort () const
	Becomes deprecated soon. Replaced by ComposedNode::CheckConsistency. More...

virtual bool	edAreAllInputPortInitialized () const
	Becomes deprecated soon. Replaced by ComposedNode::CheckConsistency. More...

InPort *	getInPort (const std::string &name) const throw (Exception)

InPropertyPort *	getInPropertyPort () const throw (Exception)

std::list< ComposedNode * >	getAllAscendanceOf (ComposedNode *levelToStop=0) const

bool	operator> (const Node &other) const

bool	operator< (const Node &other) const

std::string	getImplementation () const

virtual void	setProperty (const std::string &name, const std::string &value)

virtual std::string	getProperty (const std::string &name)

std::map< std::string, std::string >	getProperties ()

std::map< std::string, std::string >	getPropertyMap ()

virtual void	setProperties (std::map< std::string, std::string > properties)

virtual Proc *	getProc ()

virtual const Proc *	getProc () const

std::string	getQualifiedName () const
	same as Node::getName() in most cases, but differs for children of switch More...

int	getNumId ()
	return node instance identifiant, unique for each node instance More...

std::vector< std::pair < std::string, int > >	getDPLScopeInfo (ComposedNode *gfn)

virtual void	applyDPLScope (ComposedNode *gfn)

virtual void	sendEvent (const std::string &event)
	emit notification to all observers registered with the dispatcher More...

virtual void	sendEvent2 (const std::string &event, void *something)
	emit notification to all observers registered with the dispatcher More...

virtual std::string	getErrorDetails () const

virtual void	setErrorDetails (const std::string &error)

virtual void	modified ()
	Sets Node in modified state and its father if it exists. More...

virtual int	isModified ()

virtual int	isValid ()
	indicates if the node is valid (returns 1) or not (returns 0) More...

virtual std::string	getContainerLog ()
	returns a string that contains the name of the container log file if it exists More...

virtual void	ensureLoading ()
	Put this node into TOLOAD state when possible. More...

virtual void	getCoupledNodes (std::set< Task * > &coupledNodes)

Public Member Functions inherited from YACS::ENGINE::Scheduler
virtual	~Scheduler ()

Static Public Member Functions
static int	getFEDeltaBetween (OutPort start, InPort end)

static void	InterceptorizeNameOfPort (std::string &portName)

Static Public Attributes
static const char	NAME_OF_SPLITTERNODE [] ="splitter"

static const char	INTERCEPTOR_STR [] ="_interceptor"

Protected Member Functions
Node *	simpleClone (ComposedNode *father, bool editionOnly=true) const

void	checkLinkPossibility (OutPort start, const std::list< ComposedNode > &pointsOfViewStart, InPort end, const std::list< ComposedNode > &pointsOfViewEnd) throw (Exception)

YACS::Event	updateStateOnFinishedEventFrom (Node *node)
	Method used to notify the node that a child node has finished. More...

YACS::Event	updateStateForInitNodeOnFinishedEventFrom (Node *node, unsigned int id)

YACS::Event	updateStateForWorkNodeOnFinishedEventFrom (Node *node, unsigned int id, bool isNormalFinish)

YACS::Event	updateStateForFinalizeNodeOnFinishedEventFrom (Node *node, unsigned int id)

YACS::Event	updateStateOnFailedEventFrom (Node node, const Executor execInst)
	Method used to notify the node that a child node has failed. More...

void	buildDelegateOf (std::pair< OutPort , OutPort > &port, InPort finalTarget, const std::list< ComposedNode > &pointsOfView)

void	getDelegateOf (std::pair< OutPort , OutPort > &port, InPort finalTarget, const std::list< ComposedNode > &pointsOfView) throw (Exception)

void	releaseDelegateOf (OutPort portDwn, OutPort portUp, InPort finalTarget, const std::list< ComposedNode > &pointsOfView) throw (Exception)

void	cleanDynGraph ()

void	pushAllSequenceValues ()

void	createOutputOutOfScopeInterceptors (int branchNb)

void	prepareSequenceValues (int sizeOfSamples)

OutPort *	getDynOutPortByAbsName (int branchNb, const std::string &name)

void	storeOutValsInSeqForOutOfScopeUse (int rank, int branchNb)

Protected Member Functions inherited from YACS::ENGINE::DynParaLoop
	DynParaLoop (const std::string &name, TypeCode *typeOfDataSplitted)

virtual	~DynParaLoop ()

	DynParaLoop (const DynParaLoop &other, ComposedNode *father, bool editionOnly)

void	buildDelegateOf (InPort &port, OutPort initialStart, const std::list< ComposedNode * > &pointsOfView)

void	checkCFLinks (const std::list< OutPort * > &starts, InputPort *end, unsigned char &alreadyFed, bool direction, LinkInfo &info) const
	check control flow links More...

void	checkControlDependancy (OutPort start, InPort end, bool cross, std::map< ComposedNode , std::list< OutPort >, SortHierarc > &fw, std::vector< OutPort * > &fwCross, std::map< ComposedNode , std::list< OutPort >, SortHierarc > &bw, LinkInfo &info) const

void	cleanDynGraph ()

void	prepareInputsFromOutOfScope (int branchNb)

void	putValueOnBranch (Any *val, unsigned branchId, bool first)

TypeOfNode	getIdentityOfNotifyerNode (const Node *node, unsigned &id)

InputPort *	getDynInputPortByAbsName (int branchNb, const std::string &name, bool initNodeAdmitted)

virtual void	forwardExecStateToOriginalBody (Node *execNode)

std::vector< Node * >	cloneAndPlaceNodesCoherently (const std::vector< Node * > &origNodes)
	Clone nodes and make their placement consistent with the placement of the original ones. More...

Node *	checkConsistencyAndSetNode (Node &nodeToReplace, Node DISOWNnode)
	This method is used to factorize methods edSetNode, edSetInitNode and edSetFinalizeNode. More...

Node *	removeNode (Node *&nodeToRemove)
	This method is used to factorize methods edRemoveNode, edRemoveInitNode and edRemoveFinalizeNode. More...

virtual void	shutdown (int level)
	Stop all pending activities of the composed node. More...

Protected Member Functions inherited from YACS::ENGINE::ComposedNode
	ComposedNode (const std::string &name)

	ComposedNode (const ComposedNode &other, ComposedNode *father)

void	performDuplicationOfPlacement (const Node &other)
	performs a duplication of placement using clone method of containers and components. clone behaviour is driven by attachOnCloning attribute. More...

void	performShallowDuplicationOfPlacement (const Node &other)
	performs a also duplication of placement but here containers and components are not copied at all whatever the value of attachedOnCloning. More...

void	edDisconnectAllLinksWithMe ()

YACS::Event	updateStateFrom (Node node, YACS::Event event, const Executor execInst)
	Update node state on receiving event from a node. More...

virtual YACS::Event	updateStateOnStartEventFrom (Node *node)
	Method used to notify the node that a child node has started. More...

virtual void	getDelegateOf (InPort &port, OutPort initialStart, const std::list< ComposedNode * > &pointsOfView) throw (Exception)

virtual void	releaseDelegateOf (InPort &port, OutPort initialStart, const std::list< ComposedNode * > &pointsOfView) throw (Exception)

void	checkInMyDescendance (Node *nodeToTest) const throw (Exception)
	Check if a node is in the descendance of this node. More...

template<class PORT >
std::string	getPortName (const PORT *port) const throw (Exception)

void	checkNoCrossHierachyWith (Node *node) const throw (Exception)

virtual void	performCFComputations (LinkInfo &info) const
	perform recursively all CF computations. More...

virtual void	destructCFComputations (LinkInfo &info) const
	destroy recursively all results of initial computations. More...

Node *	getLowestNodeDealingAll (const std::list< OutPort * > &ports) const

void	checkLinksCoherenceRegardingControl (const std::vector< OutPort * > &starts, InputPort *end, LinkInfo &info) const throw (Exception)

void	solveObviousOrDelegateCFLinks (const std::list< OutPort * > &starts, InputPort *end, unsigned char &alreadyFed, bool direction, LinkInfo &info) const

Protected Member Functions inherited from YACS::ENGINE::Node
	Node (const std::string &name)

	Node (const Node &other, ComposedNode *father)

virtual void	exForwardFailed ()

virtual void	exForwardFinished ()

Protected Attributes
int	_currentIndex

SplitterNode	_splitterNode

FakeNodeForForEachLoop *	_nodeForSpecialCases

std::vector< AnySplitOutputPort * >	_outGoingPorts

std::vector < InterceptorInputPort * >	_intecptrsForOutGoingPorts
	ports linked to node outside the current scope More...

unsigned	_execCurrentId
	ports created for TypeCodes correctness More...

std::vector< SequenceAny * >	_execVals

std::vector< std::vector < AnyInputPort * > >	_execOutGoingPorts

ForEachLoopPassedData *	_passedData

Protected Attributes inherited from YACS::ENGINE::DynParaLoop
Node *	_node

Node *	_initNode

Node *	_finalizeNode

unsigned	_nbOfEltConsumed

std::vector< int >	_execIds

AnyInputPort	_nbOfBranches

AnyOutputPort	_splittedPort

std::vector< Node * >	_execNodes

std::vector< Node * >	_execInitNodes

std::vector< Node * >	_execFinalizeNodes

int	_initializingCounter

int	_unfinishedCounter

int	_failedCounter

Static Protected Attributes
static const int	NOT_RUNNING_BRANCH_ID =-1

Static Protected Attributes inherited from YACS::ENGINE::DynParaLoop
static const char	NAME_OF_SPLITTED_SEQ_OUT [] = "evalSamples"

static const char	OLD_NAME_OF_SPLITTED_SEQ_OUT [] = "SmplPrt"

static const char	NAME_OF_NUMBER_OF_BRANCHES [] ="nbBranches"

Static Protected Attributes inherited from YACS::ENGINE::ComposedNode
static const char	SEP_CHAR_BTW_LEVEL [] ="."

static const unsigned char	FED_ST = 2

static const unsigned char	FREE_ST = 0

static const unsigned char	FED_DS_ST = 1

Static Protected Attributes inherited from YACS::ENGINE::Node
static const char	SEP_CHAR_IN_PORT [] ="."

static int	_total = 0

Private Member Functions
int	getFinishedId ()

Friends
class	SplitterNode

class	FakeNodeForForEachLoop

Additional Inherited Members
Public Attributes inherited from YACS::ENGINE::Node
YACS::Colour	_colour

Protected Types inherited from YACS::ENGINE::DynParaLoop
enum	TypeOfNode { INIT_NODE = 5, WORK_NODE = 6, FINALIZE_NODE = 7 }

Static Protected Member Functions inherited from YACS::ENGINE::ComposedNode
static bool	splitNamesBySep (const std::string &globalName, const char separator[], std::string &firstPart, std::string &lastPart, bool priority) throw (Exception)
	Splits name globalName in 2 parts using separator. More...

Detailed Description

Loop node for parametric calculation.

Definition at line 153 of file ForEachLoop.hxx.

Constructor & Destructor Documentation

ForEachLoop::ForEachLoop	(	const std::string &	name,
		TypeCode *	typeOfDataSplitted
	)

Definition at line 464 of file ForEachLoop.cxx.

Referenced by simpleClone().

                                                                            :DynParaLoop(name,typeOfDataSplitted),
                                                                                 _splitterNode(NAME_OF_SPLITTERNODE,typeOfDataSplitted,this),
                                                                                 _execCurrentId(0),_nodeForSpecialCases(0),_currentIndex(0),_passedData(0)
 {
 }

ForEachLoop::ForEachLoop	(	const ForEachLoop &	other,
		ComposedNode *	father,
		bool	editionOnly
	)

Definition at line 470 of file ForEachLoop.cxx.

References _intecptrsForOutGoingPorts, _outGoingPorts, YACS::ENGINE::AnySplitOutputPort::addRepr(), getOutPort(), YACS::ENGINE::ComposedNode::getOutPortName(), CORBAEngineTest::i, and YACS::ENGINE::InterceptorInputPort::setRepr().

                                                                                         :DynParaLoop(other,father,editionOnly),
                                                                                            _splitterNode(other._splitterNode,this),
                                                                                            _execCurrentId(0),_nodeForSpecialCases(0),_currentIndex(0),_passedData(0)
 {
   int i=0;
   if(!editionOnly)
     for(vector<AnySplitOutputPort *>::const_iterator iter2=other._outGoingPorts.begin();iter2!=other._outGoingPorts.end();iter2++,i++)
       {
         AnySplitOutputPort *temp=new AnySplitOutputPort(*(*iter2),this);
         InterceptorInputPort *interc=new InterceptorInputPort(*other._intecptrsForOutGoingPorts[i],this);
         temp->addRepr(getOutPort(other.getOutPortName((*iter2)->getRepr())),interc);
         interc->setRepr(temp);
         _outGoingPorts.push_back(temp);
         _intecptrsForOutGoingPorts.push_back(interc);
       }
 }

ForEachLoop::~ForEachLoop ( )

Definition at line 492 of file ForEachLoop.cxx.

References _intecptrsForOutGoingPorts, _outGoingPorts, _passedData, and cleanDynGraph().

 {
   cleanDynGraph();
   for(vector<AnySplitOutputPort *>::iterator iter=_outGoingPorts.begin();iter!=_outGoingPorts.end();iter++)
     delete *iter;
   for(vector<InterceptorInputPort *>::iterator iter2=_intecptrsForOutGoingPorts.begin();iter2!=_intecptrsForOutGoingPorts.end();iter2++)
     delete *iter2;
   delete _passedData;
 }

Member Function Documentation

void ForEachLoop::accept ( Visitor * visitor )

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 1085 of file ForEachLoop.cxx.

References YACS::ENGINE::Visitor::visitForEachLoop().

 {
   visitor->visitForEachLoop(this);
 }

void ForEachLoop::assignPassedResults	(	const std::vector< unsigned int > &	passedIds,
		const std::vector< SequenceAny * > &	passedOutputs,
		const std::vector< std::string > &	nameOfOutputs
	)

This method is typically useful for post-mortem relaunch to avoid to recompute already passed cases. This method takes in input exactly the parameters retrieved by getPassedResults method.

Definition at line 1201 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::_failedCounter, and _passedData.

Referenced by YACS::ENGINE::nodeParser::onEnd().

 {
   delete _passedData;
   _failedCounter=0;
   _passedData=new ForEachLoopPassedData(passedIds,passedOutputs,nameOfOutputs);
 }

void ForEachLoop::buildDelegateOf	(	std::pair< OutPort , OutPort > &	port,
		InPort *	finalTarget,
		const std::list< ComposedNode * > &	pointsOfView
	)

protectedvirtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 905 of file ForEachLoop.cxx.

References _intecptrsForOutGoingPorts, _outGoingPorts, YACS::ENGINE::AnySplitOutputPort::addRepr(), YACS::ENGINE::DynParaLoop::buildDelegateOf(), YACS::ENGINE::DataPort::edGetType(), getFEDeltaBetween(), YACS::ENGINE::ComposedNode::getPortName(), CORBAEngineTest::i, InterceptorizeNameOfPort(), YACS::ENGINE::OutputPort::NAME, YACS::ENGINE::TypeCode::sequenceTc(), YACS::ENGINE::InterceptorInputPort::setRepr(), and YACS::ENGINE::TypeCode::subContentType().

 {
   DynParaLoop::buildDelegateOf(port,finalTarget,pointsOfView);
   string typeOfPortInstance=(port.first)->getNameOfTypeOfCurrentInstance();
   if(typeOfPortInstance==OutputPort::NAME)
     {
       vector<AnySplitOutputPort *>::iterator iter=_outGoingPorts.begin();
       int i=0;
       for(;iter!=_outGoingPorts.end();iter++,i++)
         if((*iter)->getRepr()==port.first || *iter==port.first)
           break;
       if(iter!=_outGoingPorts.end())
         {
           if(*iter!=port.first)
             {
               (*iter)->incrRef();
               (*iter)->addRepr(port.first,_intecptrsForOutGoingPorts[i]);
             }
           port.first=*iter;
         }
       else
         {
           TypeCode *tcTrad((YACS::ENGINE::TypeCode*)finalTarget->edGetType()->subContentType(getFEDeltaBetween(port.first,finalTarget)));
           TypeCodeSeq *newTc=(TypeCodeSeq *)TypeCode::sequenceTc("","",tcTrad);
           // The out going ports belong to the ForEachLoop, whereas
           // the delegated port belongs to a node child of the ForEachLoop.
           // The name of the delegated port contains dots (bloc.node.outport),
           // whereas the name of the out going port shouldn't do.
           std::string outputPortName(getPortName(port.first));
           InterceptorizeNameOfPort(outputPortName);
           AnySplitOutputPort *newPort(new AnySplitOutputPort(outputPortName,this,newTc));
           InterceptorInputPort *intercptor(new InterceptorInputPort(outputPortName + "_in",this,tcTrad));
           intercptor->setRepr(newPort);
           newTc->decrRef();
           newPort->addRepr(port.first,intercptor);
           _outGoingPorts.push_back(newPort);
           _intecptrsForOutGoingPorts.push_back(intercptor);
           port.first=newPort;
         }
     }
   else
     throw Exception("ForEachLoop::buildDelegateOf : not implemented for DS because not specified");
 }

void ForEachLoop::checkLinkPossibility	(	OutPort *	start,
		const std::list< ComposedNode * > &	pointsOfViewStart,
		InPort *	end,
		const std::list< ComposedNode * > &	pointsOfViewEnd
	)		throw (Exception)

protectedvirtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 1066 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::checkLinkPossibility().

 {
   DynParaLoop::checkLinkPossibility(start, pointsOfViewStart, end, pointsOfViewEnd);
   if(end->getNode() == &_splitterNode)
     throw Exception("Illegal link within a foreach loop: \
 the 'SmplsCollection' port cannot be linked within the scope of the loop.");
   if(end == &_nbOfBranches)
     throw Exception("Illegal link within a foreach loop: \
 the 'nbBranches' port cannot be linked within the scope of the loop.");
 }

void ForEachLoop::checkNoCyclePassingThrough ( Node * node ) throw (Exception)

virtual

Implements YACS::ENGINE::ComposedNode.

Definition at line 665 of file ForEachLoop.cxx.

 {
   //TO DO
 }

void ForEachLoop::cleanDynGraph ( )

protected

Definition at line 1002 of file ForEachLoop.cxx.

References _execOutGoingPorts, _execVals, and YACS::ENGINE::DynParaLoop::cleanDynGraph().

Referenced by init(), resetState(), and ~ForEachLoop().

 {
   DynParaLoop::cleanDynGraph();
   for(vector< SequenceAny *>::iterator iter3=_execVals.begin();iter3!=_execVals.end();iter3++)
     (*iter3)->decrRef();
   _execVals.clear();
   for(vector< vector<AnyInputPort *> >::iterator iter4=_execOutGoingPorts.begin();iter4!=_execOutGoingPorts.end();iter4++)
     for(vector<AnyInputPort *>::iterator iter5=(*iter4).begin();iter5!=(*iter4).end();iter5++)
       delete *iter5;
   _execOutGoingPorts.clear();
 }

void ForEachLoop::createOutputOutOfScopeInterceptors ( int branchNb )

protected

Definition at line 1049 of file ForEachLoop.cxx.

References _execOutGoingPorts, _outGoingPorts, DEBTRACE, getDynOutPortByAbsName(), YACS::ENGINE::ComposedNode::getOutPortName(), and CORBAEngineTest::i.

Referenced by exUpdateState().

 {
   vector<AnySplitOutputPort *>::iterator iter=_outGoingPorts.begin();
   int i=0;
   for(;iter!=_outGoingPorts.end();iter++,i++)
     {
       DEBTRACE( (*iter)->getName() << " " << (*iter)->edGetType()->kind() );
       //AnyInputPort *interceptor=new AnyInputPort((*iter)->getName(),this,(*iter)->edGetType());
       OutPort *portOut=getDynOutPortByAbsName(branchNb,getOutPortName(((*iter)->getRepr())));
       DEBTRACE( portOut->getName() );
       TypeCode *tc((TypeCode *)(*iter)->edGetType()->contentType());
       AnyInputPort *interceptor=new AnyInputPort((*iter)->getName(),this,tc);
       portOut->addInPort(interceptor);
       _execOutGoingPorts[branchNb].push_back(interceptor);
     }
 }

InputPort* YACS::ENGINE::ForEachLoop::edGetSeqOfSamplesPort ( )

inline

Definition at line 189 of file ForEachLoop.hxx.

Referenced by YACS::HMI::EditionForEachLoop::onModifyCollection().

189 { return &_splitterNode._dataPortToDispatch; }

void ForEachLoop::exUpdateProgress ( )

Definition at line 632 of file ForEachLoop.cxx.

References YACS::ENGINE::Node::sendEvent().

Referenced by init(), updateStateForFinalizeNodeOnFinishedEventFrom(), and updateStateForWorkNodeOnFinishedEventFrom().

 {
   // emit notification to all observers registered with the dispatcher on any change of the node's state
   sendEvent("progress");
 }

void ForEachLoop::exUpdateState ( )

virtual

Update the node state.

Note: : Update the '_state' attribute. Typically called by 'this->_inGate' when 'this->_inGate' is ready.

Called by InGate::exNotifyFromPrecursor

Reimplemented from YACS::ENGINE::Node.

Definition at line 514 of file ForEachLoop.cxx.

 {
   DEBTRACE("ForEachLoop::exUpdateState");
   if(_state == YACS::DISABLED)
     return;
   if(_state == YACS::DONE)
     return;
   if(_inGate.exIsReady())
     {
       //internal graph update
       int i;
       int nbOfBr(_nbOfBranches.getIntValue()),nbOfElts(_splitterNode.getNumberOfElements()),nbOfEltsDone(0);
       if(_passedData)
         {
           _passedData->checkCompatibilyWithNb(nbOfElts);
           nbOfEltsDone=_passedData->getNumberOfEltsAlreadyDone();
         }
       int nbOfEltsToDo(nbOfElts-nbOfEltsDone);
 
       DEBTRACE("nbOfElts=" << nbOfElts);
       DEBTRACE("nbOfBr=" << nbOfBr);
 
       if(nbOfEltsToDo==0)
         {
           prepareSequenceValues(0);
           delete _nodeForSpecialCases;
           _nodeForSpecialCases=new FakeNodeForForEachLoop(this,true);
           setState(YACS::ACTIVATED);
           return ;
         }
       if(nbOfBr<=0)
         {
           delete _nodeForSpecialCases;
           _nodeForSpecialCases=new FakeNodeForForEachLoop(this,getAllOutPortsLeavingCurrentScope().empty());
           setState(YACS::ACTIVATED);
           return ;
         }
       if(nbOfBr>nbOfEltsToDo)
         nbOfBr=nbOfEltsToDo;
       _execNodes.resize(nbOfBr);
       _execIds.resize(nbOfBr);
       _execOutGoingPorts.resize(nbOfBr);
       prepareSequenceValues(nbOfElts);
       if(_initNode)
         _execInitNodes.resize(nbOfBr);
       _initializingCounter = 0;
       if (_finalizeNode)
         _execFinalizeNodes.resize(nbOfBr);
 
       vector<Node *> origNodes;
       origNodes.push_back(_initNode);
       origNodes.push_back(_node);
       origNodes.push_back(_finalizeNode);
 
       //Conversion exceptions can be thrown by createOutputOutOfScopeInterceptors 
       //so catch them to control errors
       try
         {
           for(i=0;i<nbOfBr;i++)
             {
               DEBTRACE( "-------------- 2" );
               vector<Node *> clonedNodes = cloneAndPlaceNodesCoherently(origNodes);
               if(_initNode)
                 _execInitNodes[i] = clonedNodes[0];
               _execNodes[i] = clonedNodes[1];
               if(_finalizeNode)
                 _execFinalizeNodes[i] = clonedNodes[2];
               DEBTRACE( "-------------- 4" );
               prepareInputsFromOutOfScope(i);
               DEBTRACE( "-------------- 5" );
               createOutputOutOfScopeInterceptors(i);
               DEBTRACE( "-------------- 6" );
             }
           for(i=0;i<nbOfBr;i++)
             {
               DEBTRACE( "-------------- 1 " << i << " " << _execCurrentId);
               _execIds[i]=_execCurrentId;
               int posInAbs(_execCurrentId);
               if(_passedData)
                 posInAbs=_passedData->toAbsId(_execCurrentId);
               _splitterNode.putSplittedValueOnRankTo(posInAbs,i,true);
               _execCurrentId++;
               DEBTRACE( "-------------- 7" );
             }
           if(_passedData)
             {
               _passedData->checkLevel2(_execOutGoingPorts[0]);
               _passedData->assignAlreadyDone(_execVals);
             }
         }
       catch(YACS::Exception& ex)
         {
           //ForEachLoop must be put in error and the exception rethrown to notify the caller
           DEBTRACE( "ForEachLoop::exUpdateState: " << ex.what() );
           setState(YACS::ERROR);
           exForwardFailed();
           throw;
         }
 
       setState(YACS::ACTIVATED); // move the calling of setState method there for adding observers for clone nodes in GUI part
 
       //let's go
       for(i=0;i<nbOfBr;i++)
         if(_initNode)
           {
             _execInitNodes[i]->exUpdateState();
             _initializingCounter++;
           }
         else
           {
             _nbOfEltConsumed++;
             _execNodes[i]->exUpdateState();
           }
 
       forwardExecStateToOriginalBody(_execNodes[nbOfBr-1]);
     }
 }

Node * ForEachLoop::getChildByShortName ( const std::string & name ) const throw (Exception)

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 716 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::getChildByShortName().

Referenced by YACS::looptypeParser< T >::foreach(), YACS::casetypeParser::foreach(), and YACS::bloctypeParser< T >::foreach().

 {
   if(name==NAME_OF_SPLITTERNODE)
     return (Node *)&_splitterNode;
   else
     return DynParaLoop::getChildByShortName(name);
 }

int YACS::ENGINE::ForEachLoop::getCurrentIndex ( ) const

inline

Definition at line 201 of file ForEachLoop.hxx.

Referenced by getProgressWeight().

201 { return _currentIndex; }

void ForEachLoop::getDelegateOf	(	std::pair< OutPort , OutPort > &	port,
		InPort *	finalTarget,
		const std::list< ComposedNode * > &	pointsOfView
	)		throw (Exception)

protectedvirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 949 of file ForEachLoop.cxx.

References YACS::ENGINE::OutputPort::NAME.

 {
   string typeOfPortInstance=(port.first)->getNameOfTypeOfCurrentInstance();
   if(typeOfPortInstance==OutputPort::NAME)
     {
       vector<AnySplitOutputPort *>::iterator iter=_outGoingPorts.begin();
       for(;iter!=_outGoingPorts.end();iter++)
         if((*iter)->getRepr()==port.first)
           break;
       if(iter==_outGoingPorts.end())
         {
           string what("ForEachLoop::getDelegateOf : Port with name "); what+=port.first->getName(); what+=" not exported by ForEachLoop "; what+=_name; 
           throw Exception(what);
         }
       else
         port.first=(*iter);
     }
   else
     throw Exception("ForEachLoop::getDelegateOf : not implemented because not specified");
 }

OutPort * ForEachLoop::getDynOutPortByAbsName	(	int	branchNb,
		const std::string &	name
	)

protected

Definition at line 993 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::_execNodes, YACS::ENGINE::ComposedNode::getChildByName(), YACS::ENGINE::Node::SEP_CHAR_IN_PORT, and YACS::ENGINE::ComposedNode::splitNamesBySep().

Referenced by createOutputOutOfScopeInterceptors().

 {
   string portName, nodeName;
   splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,false);
   Node *staticChild = getChildByName(nodeName);
   return _execNodes[branchNb]->getOutPort(portName);//It's impossible(garanteed by YACS::ENGINE::ForEachLoop::buildDelegateOf)
   //that a link starting from _initNode goes out of scope of 'this'.
 }

unsigned YACS::ENGINE::ForEachLoop::getExecCurrentId ( ) const

inline

Definition at line 186 of file ForEachLoop.hxx.

186 { return _execCurrentId; } // for update progress bar on GUI part

int ForEachLoop::getFEDeltaBetween	(	OutPort *	start,
		InPort *	end
	)

static

Definition at line 1208 of file ForEachLoop.cxx.

References YACS::ENGINE::Node::getFather(), YACS::ENGINE::ComposedNode::getLowestCommonAncestor(), YACS::ENGINE::Port::getNode(), and PMMLBasicsTestLauncher::ret.

Referenced by buildDelegateOf().

 {
   Node *ns(start->getNode()),*ne(end->getNode());
   ComposedNode *co(getLowestCommonAncestor(ns,ne));
   int ret(0);
   Node *work(ns);
   while(work!=co)
     {
       ForEachLoop *isFE(dynamic_cast<ForEachLoop *>(work));
       if(isFE)
         ret++;
       work=work->getFather();
     }
   if(dynamic_cast<AnySplitOutputPort *>(start))
     ret--;
   return ret;
 }

int ForEachLoop::getFinishedId ( )

private

Definition at line 1025 of file ForEachLoop.cxx.

References _passedData, _splitterNode, YACS::ENGINE::SplitterNode::getNumberOfElements(), and YACS::ENGINE::ForEachLoopPassedData::getNumberOfElementsToDo().

Referenced by updateStateForWorkNodeOnFinishedEventFrom().

 {
   if(!_passedData)
     return _splitterNode.getNumberOfElements();
   else
     return _passedData->getNumberOfElementsToDo();
 }

InputPort * ForEachLoop::getInputPort ( const std::string & name ) const throw (Exception)

virtual

Get an input port given its name.

Contrary to YACS::ENGINE::ComposedNode::getOutputPort, this method is NOT recursive and so the leaf of type ElementaryNode aggregating this InputPort is directly invoked.

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 688 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::getInputPort(), and YACS::ENGINE::SplitterNode::NAME_OF_SEQUENCE_INPUT.

Referenced by YACS::ENGINE::portParser::onEnd().

 {
   if(name==SplitterNode::NAME_OF_SEQUENCE_INPUT)
     return (InputPort *)&_splitterNode._dataPortToDispatch;
   else
     return DynParaLoop::getInputPort(name);
 }

std::list< InputPort * > ForEachLoop::getLocalInputPorts ( ) const

virtual

redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 681 of file ForEachLoop.cxx.

References YACS::ENGINE::SplitterNode::_dataPortToDispatch, _splitterNode, YACS::ENGINE::DynParaLoop::getLocalInputPorts(), and PMMLBasicsTestLauncher::ret.

Referenced by YACS::ENGINE::VisitorSalomeSaveState::visitForEachLoop().

 {
   list<InputPort *> ret=DynParaLoop::getLocalInputPorts();
   ret.push_back((InputPort *)&_splitterNode._dataPortToDispatch);
   return ret;
 }

std::list< OutputPort * > ForEachLoop::getLocalOutputPorts ( ) const

virtual

redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 1078 of file ForEachLoop.cxx.

References getOutputPort(), YACS::ENGINE::DynParaLoop::NAME_OF_SPLITTED_SEQ_OUT, and PMMLBasicsTestLauncher::ret.

 {
   list<OutputPort *> ret;
   ret.push_back(getOutputPort(NAME_OF_SPLITTED_SEQ_OUT)); 
   return ret;
 }

int ForEachLoop::getNbOfElementsToBeProcessed ( ) const

Definition at line 1156 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::_finalizeNode, YACS::ENGINE::DynParaLoop::_initNode, YACS::ENGINE::DynParaLoop::_nbOfBranches, _splitterNode, YACS::ENGINE::AnyInputPort::getIntValue(), and YACS::ENGINE::SplitterNode::getNumberOfElements().

Referenced by getProgress(), and getProgressWeight().

 {
   int nbBranches = _nbOfBranches.getIntValue();
   return _splitterNode.getNumberOfElements()
          + (_initNode ? nbBranches:0)
          + (_finalizeNode ? nbBranches:0) ;
 }

int ForEachLoop::getNumberOfInputPorts ( ) const

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 660 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::getNumberOfInputPorts().

 {
   return DynParaLoop::getNumberOfInputPorts()+1;
 }

OutPort * ForEachLoop::getOutPort ( const std::string & name ) const throw (Exception)

virtual

Note: : Contrary to getOutputPort method, this method returns the output port at highest level, possible. That is to say in some ComposedNode, like ForEachLoop or Switch, an outport inside 'this' is seen differently than the true outport.

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 706 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::getOutPort().

Referenced by ForEachLoop().

 {
   for(vector<AnySplitOutputPort *>::const_iterator iter=_outGoingPorts.begin();iter!=_outGoingPorts.end();iter++)
     {
       if(name==(*iter)->getName())
         return (OutPort *)(*iter);
     }
   return DynParaLoop::getOutPort(name);
 }

OutputPort * ForEachLoop::getOutputPort ( const std::string & name ) const throw (Exception)

virtual

Get an output port given its name.

Contrary to YACS::ENGINE::ComposedNode::getInputPort, this method is recursive and go down hierarchy step by step to complete its work.

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 696 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::getOutputPort().

Referenced by getLocalOutputPorts().

 {
   for(vector<AnySplitOutputPort *>::const_iterator iter=_outGoingPorts.begin();iter!=_outGoingPorts.end();iter++)
     {
       if(name==(*iter)->getName())
         return (OutputPort *)(*iter);
     }
   return DynParaLoop::getOutputPort(name);
 }

const YACS::ENGINE::TypeCode * ForEachLoop::getOutputPortType ( const std::string & portName ) const

Parameters

portName : "interceptorized" name of port.

Definition at line 1258 of file ForEachLoop.cxx.

References _outGoingPorts, YACS::ENGINE::TypeCode::contentType(), DEBTRACE, YACS::ENGINE::ComposedNode::getPortName(), and PMMLBasicsTestLauncher::ret.

Referenced by YACS::ENGINE::nodeParser::onEnd().

 {
   const YACS::ENGINE::TypeCode* ret=NULL;
   vector<AnySplitOutputPort *>::const_iterator it;
   for(it=_outGoingPorts.begin();it!=_outGoingPorts.end() && ret==NULL;it++)
   {
     std::string originalPortName(getPortName(*it));
     //InterceptorizeNameOfPort(originalPortName);
     DEBTRACE("ForEachLoop::getOutputPortType compare " << portName << " == " << originalPortName);
     if(originalPortName == portName)
     {
       ret = (*it)->edGetType()->contentType();
     }
   }
   return ret;
 }

std::vector< unsigned int > ForEachLoop::getPassedResults	(	Executor *	execut,
		std::vector< SequenceAny * > &	outputs,
		std::vector< std::string > &	nameOfOutputs
	)		const

This method allows to retrieve the state of this during execution or after. This method works even if this is NOT complete, or during execution or after a failure in this. The typical usage of this method is to retrieve the results of items that passed successfully to avoid to lose all of them if only one fails. This method has one input execut and 3 outputs.

Parameters

[in]	execut	- The single input is for threadsafety reasons because this method can be called safely during the execution of this.
[out]	outputs	- For each output ports in this linked with nodes sharing the same father than this the passed results are stored. All of the items in outputs have the same size.
[out]	nameOfOutputs	- The array with same size than outputs, that tells for each item in outputs the output port it refers to.

Returns: the list of ids among this->edGetSeqOfSamplesPort() that run successfully. The length of this returned array will be the length of all SequenceAny objects contained in outputs.

See Also: edGetSeqOfSamplesPort

Definition at line 1178 of file ForEachLoop.cxx.

References _execOutGoingPorts, _execVals, YACS::ENGINE::Executor::getTheMutexForSchedulerUpdate(), and CORBAEngineTest::i.

 {
   YACS::BASES::AutoLocker<YACS::BASES::Mutex> alck(&(execut->getTheMutexForSchedulerUpdate()));
   if(_execVals.empty())
     return std::vector<unsigned int>();
   if(_execOutGoingPorts.empty())
     return std::vector<unsigned int>();
   std::size_t sz(_execVals.size());
   outputs.resize(sz);
   nameOfOutputs.resize(sz);
   const std::vector<AnyInputPort *>& ports(_execOutGoingPorts[0]);
   for(std::size_t i=0;i<sz;i++)
     {
       outputs[i]=_execVals[i]->removeUnsetItemsFromThis();
       nameOfOutputs[i]=ports[i]->getName();
     }
   return _execVals[0]->getSetItems();
 }

ForEachLoopPassedData * ForEachLoop::getProcessedData ( ) const

This method is used to obtain the values already processed by the ForEachLoop. A new ForEachLoopPassedData object is returned. You have to delete it.

Definition at line 1230 of file ForEachLoop.cxx.

References _execOutGoingPorts, _execVals, and CORBAEngineTest::i.

Referenced by YACS::ENGINE::VisitorSalomeSaveState::visitForEachLoop().

 {
   std::vector<SequenceAny *> outputs;
   std::vector<std::string> nameOfOutputs;
   if(_execVals.empty() || _execOutGoingPorts.empty())
     return new ForEachLoopPassedData(std::vector<unsigned int>(), outputs, nameOfOutputs);
   std::size_t sz(_execVals.size());
   outputs.resize(sz);
   nameOfOutputs.resize(sz);
   const std::vector<AnyInputPort *>& ports(_execOutGoingPorts[0]);
   for(std::size_t i=0;i<sz;i++)
     {
       outputs[i]=_execVals[i]->removeUnsetItemsFromThis();
       nameOfOutputs[i]=ports[i]->getName();
     }
   return new ForEachLoopPassedData(_execVals[0]->getSetItems(), outputs, nameOfOutputs);
 }

std::string ForEachLoop::getProgress ( ) const

virtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 1121 of file ForEachLoop.cxx.

References _currentIndex, and getNbOfElementsToBeProcessed().

 {
   int nbElems(getNbOfElementsToBeProcessed());
   std::stringstream aProgress;
   if (nbElems > 0)
     aProgress << _currentIndex << "/" << nbElems;
   else
     aProgress << "0";
   return aProgress.str();
 }

list< ProgressWeight > ForEachLoop::getProgressWeight ( ) const

virtual

Get the progress weight for all elementary nodes.

Only elementary nodes have weight. For each node in the loop, the weight done is multiplied by the number of elements done and the weight total by the number total of elements

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 1137 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::edGetDirectDescendants(), getCurrentIndex(), getNbOfElementsToBeProcessed(), and PMMLBasicsTestLauncher::ret.

 {
   list<ProgressWeight> ret;
   list<Node *> setOfNode=edGetDirectDescendants();
   int elemDone=getCurrentIndex();
   int elemTotal=getNbOfElementsToBeProcessed();
   for(list<Node *>::const_iterator iter=setOfNode.begin();iter!=setOfNode.end();iter++)
     {
       list<ProgressWeight> myCurrentSet=(*iter)->getProgressWeight();
       for(list<ProgressWeight>::iterator iter=myCurrentSet.begin();iter!=myCurrentSet.end();iter++)
         {
           (*iter).weightDone=((*iter).weightTotal) * elemDone;
           (*iter).weightTotal*=elemTotal;
         }
       ret.insert(ret.end(),myCurrentSet.begin(),myCurrentSet.end());
     }
   return ret;
 }

void ForEachLoop::getReadyTasks ( std::vector< Task * > & tasks )

virtual

Implements YACS::ENGINE::Node.

Definition at line 638 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::_execFinalizeNodes, YACS::ENGINE::DynParaLoop::_execInitNodes, YACS::ENGINE::DynParaLoop::_execNodes, YACS::ENGINE::DynParaLoop::_node, _nodeForSpecialCases, YACS::ENGINE::Node::_state, YACS::ACTIVATED, YACS::ENGINE::ElementaryNode::getReadyTasks(), YACS::ENGINE::Node::setState(), and YACS::TOACTIVATE.

 {
   if(!_node)
     return;
   if(_state==YACS::TOACTIVATE) setState(YACS::ACTIVATED);
   if(_state==YACS::TOACTIVATE || _state==YACS::ACTIVATED)
     {
       if(_nodeForSpecialCases)
         {
           _nodeForSpecialCases->getReadyTasks(tasks);
           return ;
         }
       vector<Node *>::iterator iter;
       for (iter=_execNodes.begin() ; iter!=_execNodes.end() ; iter++)
         (*iter)->getReadyTasks(tasks);
       for (iter=_execInitNodes.begin() ; iter!=_execInitNodes.end() ; iter++)
         (*iter)->getReadyTasks(tasks);
       for (iter=_execFinalizeNodes.begin() ; iter!=_execFinalizeNodes.end() ; iter++)
         (*iter)->getReadyTasks(tasks);
     }
 }

std::list< InputPort * > ForEachLoop::getSetOfInputPort ( ) const

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 674 of file ForEachLoop.cxx.

References YACS::ENGINE::SplitterNode::_dataPortToDispatch, _splitterNode, YACS::ENGINE::DynParaLoop::getSetOfInputPort(), and PMMLBasicsTestLauncher::ret.

 {
   list<InputPort *> ret=DynParaLoop::getSetOfInputPort();
   ret.push_back((InputPort *)&_splitterNode._dataPortToDispatch);
   return ret;
 }

void ForEachLoop::init ( bool start = true )

virtual

initialisation of all input and output ports and gates, for execution

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 502 of file ForEachLoop.cxx.

References _currentIndex, _execCurrentId, _passedData, _splitterNode, cleanDynGraph(), exUpdateProgress(), YACS::ENGINE::DynParaLoop::init(), YACS::ENGINE::SplitterNode::init(), and YACS::ENGINE::ForEachLoopPassedData::init().

 {
   DynParaLoop::init(start);
   _splitterNode.init(start);
   _execCurrentId=0;
   cleanDynGraph();
   _currentIndex = 0;
   exUpdateProgress();
   if(_passedData)
     _passedData->init();
 }

void ForEachLoop::InterceptorizeNameOfPort ( std::string & portName )

static

Definition at line 899 of file ForEachLoop.cxx.

References INTERCEPTOR_STR.

Referenced by buildDelegateOf().

 {
   std::replace_if(portName.begin(), portName.end(), std::bind1st(std::equal_to<char>(), '.'), '_');
   portName += INTERCEPTOR_STR;
 }

void ForEachLoop::prepareSequenceValues ( int sizeOfSamples )

protected

Definition at line 1033 of file ForEachLoop.cxx.

References _execVals, _outGoingPorts, CORBAEngineTest::i, and YACS::ENGINE::SequenceAny::New().

Referenced by exUpdateState().

 {
   _execVals.resize(_outGoingPorts.size());
   vector<AnySplitOutputPort *>::iterator iter=_outGoingPorts.begin();
   for(int i=0;iter!=_outGoingPorts.end();iter++,i++)
     _execVals[i]=SequenceAny::New((*iter)->edGetType()->contentType(),sizeOfSamples);
 }

void ForEachLoop::pushAllSequenceValues ( )

protected

Definition at line 1041 of file ForEachLoop.cxx.

References _execVals, _outGoingPorts, and CORBAEngineTest::i.

Referenced by YACS::ENGINE::FakeNodeForForEachLoop::execute(), and updateStateForWorkNodeOnFinishedEventFrom().

 {
   vector<AnySplitOutputPort *>::iterator iter=_outGoingPorts.begin();
   int i=0;
   for(;iter!=_outGoingPorts.end();iter++,i++)
     (*iter)->put((const void *)_execVals[i]);
 }

void ForEachLoop::releaseDelegateOf	(	OutPort *	portDwn,
		OutPort *	portUp,
		InPort *	finalTarget,
		const std::list< ComposedNode * > &	pointsOfView
	)		throw (Exception)

protectedvirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 970 of file ForEachLoop.cxx.

References YACS::ENGINE::OutputPort::NAME, and p.

 {
   string typeOfPortInstance=portDwn->getNameOfTypeOfCurrentInstance();
   if(typeOfPortInstance==OutputPort::NAME)
     {
       vector<AnySplitOutputPort *>::iterator iter=_outGoingPorts.begin();
       vector<InterceptorInputPort *>::iterator iter2=_intecptrsForOutGoingPorts.begin();
       for(;iter!=_outGoingPorts.end();iter++,iter2++)
         if((*iter)->getRepr()==portDwn)
           break;
       //ASSERT(portUp==*iter.second)
       if((*iter)->decrRef())
         {
           AnySplitOutputPort *p=*iter;
           _outGoingPorts.erase(iter);
           delete p;
           InterceptorInputPort *ip=*iter2;
           _intecptrsForOutGoingPorts.erase(iter2);
           delete ip;
         }
     }
 }

void ForEachLoop::resetState ( int level )

virtual

Reset the state of the node and its children depending on the parameter level.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 1112 of file ForEachLoop.cxx.

References _execCurrentId, cleanDynGraph(), and YACS::ENGINE::ComposedNode::resetState().

 {
   if(level==0)return;
   DynParaLoop::resetState(level);
   _execCurrentId=0;
   //Note: cleanDynGraph is not a virtual method (must be called from ForEachLoop object) 
   cleanDynGraph();
 }

void ForEachLoop::selectRunnableTasks ( std::vector< Task * > & tasks )

virtual

Implements YACS::ENGINE::Scheduler.

Definition at line 670 of file ForEachLoop.cxx.

671 {

672 }

void ForEachLoop::setProcessedData ( ForEachLoopPassedData * processedData )

Definition at line 1248 of file ForEachLoop.cxx.

References _passedData.

 {
   if(_passedData)
     delete _passedData;
   _passedData = processedData;
 }

Node * ForEachLoop::simpleClone	(	ComposedNode *	father,
		bool	editionOnly = `true`
	)		const

protectedvirtual

Implements YACS::ENGINE::Node.

Definition at line 487 of file ForEachLoop.cxx.

References ForEachLoop().

 {
   return new ForEachLoop(*this,father,editionOnly);
 }

void ForEachLoop::storeOutValsInSeqForOutOfScopeUse	(	int	rank,
		int	branchNb
	)

protected

Definition at line 1014 of file ForEachLoop.cxx.

References _execOutGoingPorts, _execVals, and CORBAEngineTest::i.

Referenced by updateStateForWorkNodeOnFinishedEventFrom().

 {
   vector<AnyInputPort *>::iterator iter;
   int i=0;
   for(iter=_execOutGoingPorts[branchNb].begin();iter!=_execOutGoingPorts[branchNb].end();iter++,i++)
     {
       Any *val=(Any *)(*iter)->getValue();
       _execVals[i]->setEltAtRank(rank,val);
     }
 }

virtual std::string YACS::ENGINE::ForEachLoop::typeName ( )

inlinevirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 197 of file ForEachLoop.hxx.

197 {return "YACS__ENGINE__ForEachLoop";}

YACS::Event ForEachLoop::updateStateForFinalizeNodeOnFinishedEventFrom	(	Node *	node,
		unsigned int	id
	)

protected

Definition at line 868 of file ForEachLoop.cxx.

References _currentIndex, YACS::ENGINE::DynParaLoop::_finalizeNode, YACS::ENGINE::DynParaLoop::_unfinishedCounter, DEBTRACE, YACS::DONE, exUpdateProgress(), YACS::FINISH, YACS::NOEVENT, and YACS::ENGINE::Node::setState().

Referenced by updateStateOnFinishedEventFrom().

 {
   DEBTRACE("Finalize node finished on branch " << id);
   _unfinishedCounter--;
   _currentIndex++;
   exUpdateProgress();
   DEBTRACE(_unfinishedCounter << " finalize nodes still running");
   if (_unfinishedCounter == 0)
     {
       _finalizeNode->setState(YACS::DONE);
       setState(YACS::DONE);
       return YACS::FINISH;
     }
   else
     return YACS::NOEVENT;
 }

YACS::Event ForEachLoop::updateStateForInitNodeOnFinishedEventFrom	(	Node *	node,
		unsigned int	id
	)

protected

Definition at line 749 of file ForEachLoop.cxx.

References _currentIndex, YACS::ENGINE::DynParaLoop::_execNodes, YACS::ENGINE::DynParaLoop::_initializingCounter, YACS::ENGINE::DynParaLoop::_initNode, YACS::ENGINE::DynParaLoop::_nbOfEltConsumed, YACS::DONE, YACS::NOEVENT, and YACS::ENGINE::Node::setState().

Referenced by updateStateOnFinishedEventFrom().

 {
   _execNodes[id]->exUpdateState();
   _nbOfEltConsumed++;
   _initializingCounter--;
   _currentIndex++;
   if (_initializingCounter == 0)
     _initNode->setState(DONE);
   return YACS::NOEVENT;
 }

YACS::Event ForEachLoop::updateStateForWorkNodeOnFinishedEventFrom	(	Node *	node,
		unsigned int	id,
		bool	isNormalFinish
	)

protected

Parameters

[in] isNormalFinish - if true

Definition at line 763 of file ForEachLoop.cxx.

Referenced by updateStateOnFailedEventFrom(), and updateStateOnFinishedEventFrom().

 {
   _currentIndex++;
   exUpdateProgress();
   if(isNormalFinish)
     {
       int globalId(_execIds[id]);
       if(_passedData)
         globalId=_passedData->toAbsId(globalId);
       sendEvent2("progress_ok",&globalId);
       storeOutValsInSeqForOutOfScopeUse(globalId,id);
     }
   else
     {
       int globalId(_execIds[id]);
       if(_passedData)
         globalId=_passedData->toAbsId(globalId);
       sendEvent2("progress_ko",&globalId);
     }
   //
   if(_execCurrentId==getFinishedId())
     {//No more elements of _dataPortToDispatch to treat
       _execIds[id]=NOT_RUNNING_BRANCH_ID;
       //analyzing if some samples are still on treatment on other branches.
       bool isFinished(true);
       for(int i=0;i<_execIds.size() && isFinished;i++)
         isFinished=(_execIds[i]==NOT_RUNNING_BRANCH_ID);
       if(isFinished)
         {
           try
           {
               if(_failedCounter!=0)
                 {// case of keepgoing mode + a failed
                   std::ostringstream oss; oss << "Keep Going mode activated and some errors (" << _failedCounter << ")reported !";
                   DEBTRACE("ForEachLoop::updateStateOnFinishedEventFrom : "<< oss.str());
                   setState(YACS::FAILED);
                   return YACS::ABORT;
                 }
               pushAllSequenceValues();
 
               if (_node)
                 {
                   _node->setState(YACS::DONE);
 
                   ComposedNode* compNode = dynamic_cast<ComposedNode*>(_node);
                   if (compNode)
                     {
                       std::list<Node *> aChldn = compNode->getAllRecursiveConstituents();
                       std::list<Node *>::iterator iter=aChldn.begin();
                       for(;iter!=aChldn.end();iter++)
                         (*iter)->setState(YACS::DONE);
                     }
                 }
 
               if (_finalizeNode == NULL)
                 {
                   // No finalize node, we just finish the loop at the end of exec nodes execution
                   setState(YACS::DONE);
                   return YACS::FINISH;
                 }
               else
                 {
                   // Run the finalize nodes, the loop will be done only when they all finish
                   _unfinishedCounter = 0;  // This counter indicates how many branches are not finished
                   for (int i=0 ; i<_execIds.size() ; i++)
                     {
                       YASSERT(_execIds[i] == NOT_RUNNING_BRANCH_ID);
                       DEBTRACE("Launching finalize node for branch " << i);
                       _execFinalizeNodes[i]->exUpdateState();
                       _unfinishedCounter++;
                     }
                   return YACS::NOEVENT;
                 }
           }
           catch(YACS::Exception& ex)
           {
               DEBTRACE("ForEachLoop::updateStateOnFinishedEventFrom: "<<ex.what());
               //no way to push results : put following nodes in FAILED state
               //TODO could be more fine grain : put only concerned nodes in FAILED state
               exForwardFailed();
               setState(YACS::ERROR);
               return YACS::ABORT;
           }
         }
     }
   else if(_state == YACS::ACTIVATED)
     {//more elements to do and loop still activated
       _execIds[id]=_execCurrentId;
       node->init(false);
       int posInAbs(_execCurrentId);
       if(_passedData)
         posInAbs=_passedData->toAbsId(_execCurrentId);
       _splitterNode.putSplittedValueOnRankTo(posInAbs,id,false);
       _execCurrentId++;
       node->exUpdateState();
       forwardExecStateToOriginalBody(node);
       _nbOfEltConsumed++;
     }
   else
     {//elements to process and loop no more activated
       DEBTRACE("foreach loop state " << _state);
     }
   return YACS::NOEVENT;
 }

YACS::Event ForEachLoop::updateStateOnFailedEventFrom	(	Node *	node,
		const Executor *	execInst
	)

protectedvirtual

Method used to notify the node that a child node has failed.

Update the current state and return the change state

Parameters

node	: the child node that has failed

Returns: the state change

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 885 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::_failedCounter, YACS::ENGINE::DynParaLoop::getIdentityOfNotifyerNode(), YACS::ENGINE::Executor::getKeepGoingProperty(), updateStateForWorkNodeOnFinishedEventFrom(), YACS::ENGINE::DynParaLoop::updateStateOnFailedEventFrom(), and YACS::ENGINE::DynParaLoop::WORK_NODE.

 {
   unsigned int id;
   DynParaLoop::TypeOfNode ton(getIdentityOfNotifyerNode(node,id));
   // TODO: deal with keepgoing without the dependency to Executor
   if(ton!=WORK_NODE || !execInst->getKeepGoingProperty())
     return DynParaLoop::updateStateOnFailedEventFrom(node,execInst);
   else
     {
       _failedCounter++;
       return updateStateForWorkNodeOnFinishedEventFrom(node,id,false);
     }
 }

YACS::Event ForEachLoop::updateStateOnFinishedEventFrom ( Node * node )

protectedvirtual

Method used to notify the node that a child node has finished.

Update the current state and return the change state

Parameters

node	: the child node that has finished

Returns: the state change

Implements YACS::ENGINE::ComposedNode.

Definition at line 731 of file ForEachLoop.cxx.

References DEBTRACE, YACS::ENGINE::DynParaLoop::FINALIZE_NODE, YACS::ENGINE::DynParaLoop::getIdentityOfNotifyerNode(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Node::getState(), YACS::ENGINE::DynParaLoop::INIT_NODE, YACS::NOEVENT, updateStateForFinalizeNodeOnFinishedEventFrom(), updateStateForInitNodeOnFinishedEventFrom(), updateStateForWorkNodeOnFinishedEventFrom(), YACS::ENGINE::DynParaLoop::WORK_NODE, and YASSERT.

 {
   DEBTRACE("updateStateOnFinishedEventFrom " << node->getName() << " " << node->getState());
   unsigned int id;
   switch(getIdentityOfNotifyerNode(node,id))
     {
     case INIT_NODE:
       return updateStateForInitNodeOnFinishedEventFrom(node,id);
     case WORK_NODE:
       return updateStateForWorkNodeOnFinishedEventFrom(node,id,true);
     case FINALIZE_NODE:
       return updateStateForFinalizeNodeOnFinishedEventFrom(node,id);
     default:
       YASSERT(false);
     }
   return YACS::NOEVENT;
 }

void ForEachLoop::writeDot ( std::ostream & os ) const

virtual

Dump the node state to a stream.

Parameters

os	: the output stream

Reimplemented from YACS::ENGINE::Node.

Definition at line 1094 of file ForEachLoop.cxx.

References YACS::ENGINE::DynParaLoop::_node, YACS::ENGINE::Node::getColorState(), YACS::ENGINE::Node::getEffectiveState(), YACS::ENGINE::Node::getId(), YACS::ENGINE::ComposedNode::getName(), CORBAEngineTest::state, and YACS::ENGINE::Node::writeDot().

 {
   os << "  subgraph cluster_" << getId() << "  {\n" ;
   //only one node in a loop
   if(_node)
     {
       _node->writeDot(os);
       os << getId() << " -> " << _node->getId() << ";\n";
     }
   os << "}\n" ;
   os << getId() << "[fillcolor=\"" ;
   YACS::StatesForNode state=getEffectiveState();
   os << getColorState(state);
   os << "\" label=\"" << "Loop:" ;
   os << getName() <<"\"];\n";
 }