#include <ForEachLoop.hxx>

Inheritance diagram for YACS::ENGINE::ForEachLoopGen:

[legend]

Collaboration diagram for YACS::ENGINE::ForEachLoopGen:

[legend]

Public Member Functions
	ForEachLoopGen (const std::string &name, TypeCode *typeOfDataSplitted, std::unique_ptr< NbBranchesAbstract > &&branchManager)

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

	~ForEachLoopGen ()

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)

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
	Get an input port given its name. More...

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

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

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

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

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

void	cleanDynGraph () override

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)
	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)
	Remove a child node. More...

bool	isLoop () const override

virtual bool	edAddChild (Node *DISOWNnode)

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

unsigned	getNumberOfBranchesCreatedDyn () const

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

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

ComplexWeight *	getWeight ()

void	setWeight (double loopWeight)

void	getWeightRegardingDPL (ComplexWeight *weight)

bool	isMultiplicitySpecified (unsigned &value) const

void	forceMultiplicity (unsigned value)

virtual void	checkBasicConsistency () const

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

void	accept (Visitor *visitor)

Node *	getInitNode ()

Node *	getExecNode ()

Node *	getFinalizeNode ()

int	getMaxLevelOfParallelism () const

void	partitionRegardingDPL (const PartDefinition pd, std::map< ComposedNode , YACS::BASES::AutoRefCnt< PartDefinition > > &zeMap)

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
	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)
	Add a dataflow link between two data ports. More...

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

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

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

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

void	edRemoveLink (OutGate start, InGate end)
	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
	Get the input port name. More...

std::string	getOutPortName (const OutPort *) const

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

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

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

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

void	checkConsistency (LinkInfo &info) const

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

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

ComposedNode *	getRootNode () const

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

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

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

void	loaded ()

void	connected ()

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

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

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

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

void	writeDotInFile (const std::string &fileName) 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

InPropertyPort *	getInPropertyPort () const

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

bool	operator> (const Node &other) const

bool	operator< (const Node &other) const

std::string	getImplementation () const

DynParaLoop *	getClosestDPLAmongAncestors () const

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 Member Functions inherited from YACS::ENGINE::ComposedNode
static ComposedNode *	getLowestCommonAncestor (Node node1, Node node2)
	Retrieves the lowest common ancestor of 2 nodes. More...

static std::string	getLowestCommonAncestorStr (const std::string &node1, const std::string &node2)

Static Public Member Functions inherited from YACS::ENGINE::Node
static std::string	getStateName (YACS::StatesForNode state)
	Return the name of a state. More...

static void	checkValidityOfNodeName (const std::string &name)

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

static const char	INTERCEPTOR_STR [] ="_interceptor"

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

Static Public Attributes inherited from YACS::ENGINE::Node
static std::map< int, Node * >	idMap

Protected Member Functions
void	checkLinkPossibility (OutPort start, const std::list< ComposedNode > &pointsOfViewStart, InPort end, const std::list< ComposedNode > &pointsOfViewEnd)

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)

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

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, std::unique_ptr< NbBranchesAbstract > &&branchManager)

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	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)

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

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

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

void	checkNoCrossHierachyWith (Node *node) const

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

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 Node *	simpleClone (ComposedNode *father, bool editionOnly=true) const =0

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

std::unique_ptr< NbBranchesAbstract >	_nbOfBranches

AnyOutputPort	_splittedPort

std::vector< Node * >	_execNodes

std::vector< Node * >	_execInitNodes

std::vector< Node * >	_execFinalizeNodes

int	_initializingCounter

int	_unfinishedCounter

int	_failedCounter

ComplexWeight	_weight

double	_loopWeight

Protected Attributes inherited from YACS::ENGINE::Node
InGate	_inGate

OutGate	_outGate

InPropertyPort *	_inPropertyPort

std::string	_name

ComposedNode *	_father

YACS::StatesForNode	_state

int	_modified

std::string	_errorDetails

int	_numId

std::string	_implementation

std::map< std::string, std::string >	_propertyMap

Node *	_eventReceiver =nullptr

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 Protected Attributes inherited from YACS::ENGINE::ComposedNode
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)
	Splits name globalName in 2 parts using separator. More...

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

static ComposedNode *	checkHavingCommonFather (Node node1, Node node2)

Detailed Description

Definition at line 153 of file ForEachLoop.hxx.

Constructor & Destructor Documentation

◆ ForEachLoopGen() [1/2]

ForEachLoopGen::ForEachLoopGen	(	const std::string &	name,
		TypeCode *	typeOfDataSplitted,
		std::unique_ptr< NbBranchesAbstract > &&	branchManager
	)

Definition at line 469 of file ForEachLoop.cxx.

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

◆ ForEachLoopGen() [2/2]

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

Definition at line 476 of file ForEachLoop.cxx.

                                                                                                  :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);
       }
 }

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

◆ ~ForEachLoopGen()

ForEachLoopGen::~ForEachLoopGen ( )

Definition at line 493 of file ForEachLoop.cxx.

 {
   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;
 }

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

Member Function Documentation

◆ assignPassedResults()

void ForEachLoopGen::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 1209 of file ForEachLoop.cxx.

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

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

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

◆ buildDelegateOf()

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

protectedvirtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 918 of file ForEachLoop.cxx.

 {
   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("ForEachLoopGen::buildDelegateOf : not implemented for DS because not specified");
 }

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

◆ checkLinkPossibility()

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

protectedvirtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 1079 of file ForEachLoop.cxx.

 {
   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->getPort())
     throw Exception("Illegal link within a foreach loop: \
 the 'nbBranches' port cannot be linked within the scope of the loop.");
 }

References YACS::ENGINE::DynParaLoop::_nbOfBranches, _splitterNode, YACS::ENGINE::DynParaLoop::checkLinkPossibility(), and YACS::ENGINE::Port::getNode().

◆ checkNoCyclePassingThrough()

void ForEachLoopGen::checkNoCyclePassingThrough ( Node * node )

virtual

Implements YACS::ENGINE::ComposedNode.

Definition at line 677 of file ForEachLoop.cxx.

 {
   //TO DO
 }

◆ cleanDynGraph()

void ForEachLoopGen::cleanDynGraph ( )

overridevirtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 1015 of file ForEachLoop.cxx.

 {
   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();
 }

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

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

◆ createOutputOutOfScopeInterceptors()

void ForEachLoopGen::createOutputOutOfScopeInterceptors ( int branchNb )

protected

Definition at line 1062 of file ForEachLoop.cxx.

 {
   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);
     }
 }

References _execOutGoingPorts, _outGoingPorts, YACS::ENGINE::OutPort::addInPort(), DEBTRACE, getDynOutPortByAbsName(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::ComposedNode::getOutPortName(), and yacsorb.CORBAEngineTest::i.

Referenced by exUpdateState().

◆ edGetSeqOfSamplesPort()

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

inline

Definition at line 189 of file ForEachLoop.hxx.

189 { return &_splitterNode._dataPortToDispatch; }

YACS::ENGINE::SplitterNode::_dataPortToDispatch

SeqAnyInputPort _dataPortToDispatch

Definition: ForEachLoop.hxx:104

References YACS::ENGINE::SplitterNode::_dataPortToDispatch.

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

◆ exUpdateProgress()

void ForEachLoopGen::exUpdateProgress ( )

Definition at line 644 of file ForEachLoop.cxx.

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

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

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

◆ exUpdateState()

void ForEachLoopGen::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 515 of file ForEachLoop.cxx.

 {
   DEBTRACE("ForEachLoopGen::exUpdateState");
   if(_state == YACS::DISABLED)
     return;
   if(_state == YACS::DONE)
     return;
   if(_inGate.exIsReady())
     {
       //internal graph update
       int i;
       int nbOfElts(_splitterNode.getNumberOfElements()),nbOfEltsDone(0);
       int nbOfBr(_nbOfBranches->getNumberOfBranches(nbOfElts));
       if(_passedData)
         {
           _passedData->checkCompatibilyWithNb(nbOfElts);
           nbOfEltsDone=_passedData->getNumberOfEltsAlreadyDone();
         }
       int nbOfEltsToDo(nbOfElts-nbOfEltsDone);
  
       DEBTRACE("nbOfElts=" << nbOfElts);
       DEBTRACE("nbOfBr=" << nbOfBr);
       INFO_YACSTRACE("nbOfBr (" << getName() << ") = " << 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);
             }
           // clean inputs data coming from the outside in _node
           set< InPort * > portsToSetVals=getAllInPortsComingFromOutsideOfCurrentScope();
           for(auto iter : portsToSetVals)
             {
               InputPort *curPortCasted=(InputPort *) iter;//Cast granted by ForEachLoopGen::buildDelegateOf(InPort)
               if(!curPortCasted->canSafelySqueezeMemory())// this can appear strange ! if not safelySqueeze -> release. Nevertheless it is true.
                 curPortCasted->releaseData();             // these input ports have been incremented with InputPort::put into DynParaLoop::prepareInputsFromOutOfScope. So they can be released now.
             }
         }
       catch(YACS::Exception& ex)
         {
           //ForEachLoop must be put in error and the exception rethrown to notify the caller
           DEBTRACE( "ForEachLoopGen::exUpdateState: " << ex.what() );
           setState(YACS::ERROR);
           setErrorDetails(ex.what());
           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]);
     }
 }

◆ getChildByShortName()

Node * ForEachLoopGen::getChildByShortName ( const std::string & name ) const

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 728 of file ForEachLoop.cxx.

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

References _splitterNode, YACS::ENGINE::DynParaLoop::getChildByShortName(), and NAME_OF_SPLITTERNODE.

◆ getCurrentIndex()

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

inline

Definition at line 200 of file ForEachLoop.hxx.

200 { return _currentIndex; }

Referenced by getProgressWeight().

◆ getDelegateOf()

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

protectedvirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 962 of file ForEachLoop.cxx.

 {
   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("ForEachLoopGen::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("ForEachLoopGen::getDelegateOf : not implemented because not specified");
 }

References YACS::ENGINE::Node::_name, _outGoingPorts, and YACS::ENGINE::OutputPort::NAME.

◆ getDynOutPortByAbsName()

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

protected

Definition at line 1006 of file ForEachLoop.cxx.

 {
   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::ForEachLoopGen::buildDelegateOf)
   //that a link starting from _initNode goes out of scope of 'this'.
 }

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

Referenced by createOutputOutOfScopeInterceptors().

◆ getExecCurrentId()

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

inline

Definition at line 186 of file ForEachLoop.hxx.

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

◆ getFEDeltaBetween()

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

static

Definition at line 1216 of file ForEachLoop.cxx.

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

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

Referenced by buildDelegateOf().

◆ getFinishedId()

int ForEachLoopGen::getFinishedId ( )

private

Definition at line 1038 of file ForEachLoop.cxx.

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

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

Referenced by updateStateForWorkNodeOnFinishedEventFrom().

◆ getInputPort()

InputPort * ForEachLoopGen::getInputPort ( const std::string & name ) const

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 700 of file ForEachLoop.cxx.

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

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

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

◆ getLocalInputPorts()

std::list< InputPort * > ForEachLoopGen::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 693 of file ForEachLoop.cxx.

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

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

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

◆ getLocalOutputPorts()

std::list< OutputPort * > ForEachLoopGen::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 1091 of file ForEachLoop.cxx.

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

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

◆ getNbOfElementsToBeProcessed()

int ForEachLoopGen::getNbOfElementsToBeProcessed ( ) const

Definition at line 1163 of file ForEachLoop.cxx.

 {
   int nbOfElems(_splitterNode.getNumberOfElements());
   int nbBranches = _nbOfBranches->getNumberOfBranches(nbOfElems);
   return nbOfElems
          + (_initNode ? nbBranches:0)
          + (_finalizeNode ? nbBranches:0) ;
 }

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

Referenced by getProgress(), and getProgressWeight().

◆ getNumberOfInputPorts()

int ForEachLoopGen::getNumberOfInputPorts ( ) const

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 672 of file ForEachLoop.cxx.

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

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

◆ getOutPort()

OutPort * ForEachLoopGen::getOutPort ( const std::string & name ) const

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 718 of file ForEachLoop.cxx.

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

References _outGoingPorts, and YACS::ENGINE::DynParaLoop::getOutPort().

Referenced by ForEachLoopGen().

◆ getOutputPort()

OutputPort * ForEachLoopGen::getOutputPort ( const std::string & name ) const

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 708 of file ForEachLoop.cxx.

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

References _outGoingPorts, and YACS::ENGINE::DynParaLoop::getOutputPort().

Referenced by getLocalOutputPorts().

◆ getOutputPortType()

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

Parameters

portName : "interceptorized" name of port.

Definition at line 1266 of file ForEachLoop.cxx.

 {
   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("ForEachLoopGen::getOutputPortType compare " << portName << " == " << originalPortName);
     if(originalPortName == portName)
     {
       ret = (*it)->edGetType()->contentType();
     }
   }
   return ret;
 }

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

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

◆ getPassedResults()

std::vector< unsigned int > ForEachLoopGen::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 1186 of file ForEachLoop.cxx.

 {
   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();
 }

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

◆ getProcessedData()

ForEachLoopPassedData * ForEachLoopGen::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 1238 of file ForEachLoop.cxx.

 {
   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);
 }

References _execOutGoingPorts, _execVals, and yacsorb.CORBAEngineTest::i.

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

◆ getProgress()

std::string ForEachLoopGen::getProgress ( ) const

virtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 1128 of file ForEachLoop.cxx.

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

References _currentIndex, and getNbOfElementsToBeProcessed().

◆ getProgressWeight()

list< ProgressWeight > ForEachLoopGen::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 1144 of file ForEachLoop.cxx.

 {
   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;
 }

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

◆ getReadyTasks()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 650 of file ForEachLoop.cxx.

 {
   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);
     }
 }

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.

◆ getSetOfInputPort()

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

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 686 of file ForEachLoop.cxx.

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

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

◆ init()

void ForEachLoopGen::init ( bool start = true )

virtual

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

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 503 of file ForEachLoop.cxx.

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

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

◆ InterceptorizeNameOfPort()

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

static

Definition at line 912 of file ForEachLoop.cxx.

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

References INTERCEPTOR_STR.

Referenced by buildDelegateOf().

◆ prepareSequenceValues()

void ForEachLoopGen::prepareSequenceValues ( int sizeOfSamples )

protected

Definition at line 1046 of file ForEachLoop.cxx.

 {
   _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);
 }

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

Referenced by exUpdateState().

◆ pushAllSequenceValues()

void ForEachLoopGen::pushAllSequenceValues ( )

protected

Definition at line 1054 of file ForEachLoop.cxx.

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

References _execVals, _outGoingPorts, and yacsorb.CORBAEngineTest::i.

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

◆ releaseDelegateOf()

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

protectedvirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 983 of file ForEachLoop.cxx.

 {
   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;
         }
     }
 }

References _intecptrsForOutGoingPorts, _outGoingPorts, YACS::ENGINE::DataPort::getNameOfTypeOfCurrentInstance(), YACS::ENGINE::OutputPort::NAME, and p.

◆ resetState()

void ForEachLoopGen::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 1120 of file ForEachLoop.cxx.

 {
   if(level==0)return;
   DynParaLoop::resetState(level);
   _execCurrentId=0;
   cleanDynGraph();
 }

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

◆ selectRunnableTasks()

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

virtual

Implements YACS::ENGINE::Scheduler.

Definition at line 682 of file ForEachLoop.cxx.

683 {

684 }

◆ setProcessedData()

void ForEachLoopGen::setProcessedData ( ForEachLoopPassedData * processedData )

Definition at line 1256 of file ForEachLoop.cxx.

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

References _passedData.

◆ storeOutValsInSeqForOutOfScopeUse()

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

protected

Definition at line 1027 of file ForEachLoop.cxx.

 {
   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);
     }
 }

References _execOutGoingPorts, _execVals, and yacsorb.CORBAEngineTest::i.

Referenced by updateStateForWorkNodeOnFinishedEventFrom().

◆ typeName()

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

inlinevirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 196 of file ForEachLoop.hxx.

196 {return "YACS__ENGINE__ForEachLoop";}

◆ updateStateForFinalizeNodeOnFinishedEventFrom()

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

protected

Definition at line 881 of file ForEachLoop.cxx.

 {
   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;
 }

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().

◆ updateStateForInitNodeOnFinishedEventFrom()

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

protected

Definition at line 761 of file ForEachLoop.cxx.

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

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().

◆ updateStateForWorkNodeOnFinishedEventFrom()

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

protected

Parameters

[in] isNormalFinish - if true

Definition at line 775 of file ForEachLoop.cxx.

 {
   _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("ForEachLoopGen::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("ForEachLoopGen::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;
       int posInAbs(_execCurrentId);
       if(_passedData)
         posInAbs=_passedData->toAbsId(_execCurrentId);
       _splitterNode.putSplittedValueOnRankTo(posInAbs,id,false);
       //forwardExecStateToOriginalBody(node);
       node->init(false);
       _execCurrentId++;
       node->exUpdateState();
       //forwardExecStateToOriginalBody(node);
       _nbOfEltConsumed++;
     }
   else
     {//elements to process and loop no more activated
       DEBTRACE("foreach loop state " << _state);
     }
   return YACS::NOEVENT;
 }

References _currentIndex, _execCurrentId, YACS::ENGINE::DynParaLoop::_execFinalizeNodes, YACS::ENGINE::DynParaLoop::_execIds, YACS::ENGINE::DynParaLoop::_failedCounter, YACS::ENGINE::DynParaLoop::_finalizeNode, YACS::ENGINE::DynParaLoop::_nbOfEltConsumed, YACS::ENGINE::DynParaLoop::_node, _passedData, _splitterNode, YACS::ENGINE::Node::_state, YACS::ENGINE::DynParaLoop::_unfinishedCounter, YACS::ABORT, YACS::ACTIVATED, DEBTRACE, YACS::DONE, YACS::ERROR, testCppPluginInvokation::ex, YACS::ENGINE::Node::exForwardFailed(), exUpdateProgress(), YACS::ENGINE::Node::exUpdateState(), YACS::FAILED, YACS::FINISH, YACS::ENGINE::ComposedNode::getAllRecursiveConstituents(), getFinishedId(), yacsorb.CORBAEngineTest::i, YACS::ENGINE::Node::init(), YACS::ENGINE::ComposedNode::isFinished(), YACS::NOEVENT, NOT_RUNNING_BRANCH_ID, pushAllSequenceValues(), YACS::ENGINE::SplitterNode::putSplittedValueOnRankTo(), YACS::ENGINE::Node::sendEvent2(), YACS::ENGINE::Node::setState(), storeOutValsInSeqForOutOfScopeUse(), YACS::ENGINE::ForEachLoopPassedData::toAbsId(), and YASSERT.

Referenced by updateStateOnFailedEventFrom(), and updateStateOnFinishedEventFrom().

◆ updateStateOnFailedEventFrom()

YACS::Event ForEachLoopGen::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 898 of file ForEachLoop.cxx.

 {
   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);
     }
 }

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

◆ updateStateOnFinishedEventFrom()

YACS::Event ForEachLoopGen::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 743 of file ForEachLoop.cxx.

 {
   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;
 }

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.

◆ writeDot()

void ForEachLoopGen::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 1102 of file ForEachLoop.cxx.

 {
   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";
 }

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

Friends And Related Function Documentation

◆ FakeNodeForForEachLoop

friend class FakeNodeForForEachLoop

friend

Definition at line 156 of file ForEachLoop.hxx.

Referenced by exUpdateState().

◆ SplitterNode

friend class SplitterNode

friend

Definition at line 155 of file ForEachLoop.hxx.

Member Data Documentation

◆ _currentIndex

int YACS::ENGINE::ForEachLoopGen::_currentIndex

protected

Definition at line 163 of file ForEachLoop.hxx.

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

◆ _execCurrentId

unsigned YACS::ENGINE::ForEachLoopGen::_execCurrentId

protected

ports created for TypeCodes correctness

Definition at line 169 of file ForEachLoop.hxx.

Referenced by exUpdateState(), init(), resetState(), and updateStateForWorkNodeOnFinishedEventFrom().

◆ _execOutGoingPorts

std::vector< std::vector<AnyInputPort *> > YACS::ENGINE::ForEachLoopGen::_execOutGoingPorts

protected

Definition at line 171 of file ForEachLoop.hxx.

Referenced by cleanDynGraph(), createOutputOutOfScopeInterceptors(), exUpdateState(), getPassedResults(), getProcessedData(), and storeOutValsInSeqForOutOfScopeUse().

◆ _execVals

std::vector<SequenceAny *> YACS::ENGINE::ForEachLoopGen::_execVals

protected

Definition at line 170 of file ForEachLoop.hxx.

Referenced by cleanDynGraph(), exUpdateState(), getPassedResults(), getProcessedData(), prepareSequenceValues(), pushAllSequenceValues(), and storeOutValsInSeqForOutOfScopeUse().

◆ _intecptrsForOutGoingPorts

std::vector<InterceptorInputPort *> YACS::ENGINE::ForEachLoopGen::_intecptrsForOutGoingPorts

protected

ports linked to node outside the current scope

Definition at line 167 of file ForEachLoop.hxx.

Referenced by buildDelegateOf(), ForEachLoopGen(), releaseDelegateOf(), and ~ForEachLoopGen().

◆ _nodeForSpecialCases

FakeNodeForForEachLoop* YACS::ENGINE::ForEachLoopGen::_nodeForSpecialCases

protected

Definition at line 165 of file ForEachLoop.hxx.

Referenced by exUpdateState(), and getReadyTasks().

◆ _outGoingPorts

std::vector<AnySplitOutputPort *> YACS::ENGINE::ForEachLoopGen::_outGoingPorts

protected

Definition at line 166 of file ForEachLoop.hxx.

Referenced by buildDelegateOf(), createOutputOutOfScopeInterceptors(), ForEachLoopGen(), getDelegateOf(), getOutPort(), getOutputPort(), getOutputPortType(), prepareSequenceValues(), pushAllSequenceValues(), releaseDelegateOf(), and ~ForEachLoopGen().

◆ _passedData

ForEachLoopPassedData* YACS::ENGINE::ForEachLoopGen::_passedData

protected

Definition at line 172 of file ForEachLoop.hxx.

Referenced by assignPassedResults(), exUpdateState(), getFinishedId(), init(), setProcessedData(), updateStateForWorkNodeOnFinishedEventFrom(), and ~ForEachLoopGen().

◆ _splitterNode

SplitterNode YACS::ENGINE::ForEachLoopGen::_splitterNode

protected

Definition at line 164 of file ForEachLoop.hxx.

Referenced by checkLinkPossibility(), exUpdateState(), getChildByShortName(), getFinishedId(), getInputPort(), getLocalInputPorts(), getNbOfElementsToBeProcessed(), getSetOfInputPort(), init(), and updateStateForWorkNodeOnFinishedEventFrom().

◆ INTERCEPTOR_STR

const char ForEachLoopGen::INTERCEPTOR_STR ="_interceptor"

static

Definition at line 232 of file ForEachLoop.hxx.

Referenced by InterceptorizeNameOfPort().

◆ NAME_OF_SPLITTERNODE

const char ForEachLoopGen::NAME_OF_SPLITTERNODE ="splitter"

static

Definition at line 159 of file ForEachLoop.hxx.

Referenced by getChildByShortName(), and YACS::ENGINE::VisitorSaveSchema::writeSimpleDataLinks().

◆ NOT_RUNNING_BRANCH_ID

const int ForEachLoopGen::NOT_RUNNING_BRANCH_ID =-1

staticprotected

Definition at line 161 of file ForEachLoop.hxx.

Referenced by updateStateForWorkNodeOnFinishedEventFrom().

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

src/engine/ForEachLoop.hxx
src/engine/ForEachLoop.cxx

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ForEachLoopGen() [1/2]

◆ ForEachLoopGen() [2/2]

◆ ~ForEachLoopGen()

Member Function Documentation

◆ assignPassedResults()

◆ buildDelegateOf()

◆ checkLinkPossibility()

◆ checkNoCyclePassingThrough()

◆ cleanDynGraph()

◆ createOutputOutOfScopeInterceptors()

◆ edGetSeqOfSamplesPort()

◆ exUpdateProgress()

◆ exUpdateState()

◆ getChildByShortName()

◆ getCurrentIndex()

◆ getDelegateOf()

◆ getDynOutPortByAbsName()

◆ getExecCurrentId()

◆ getFEDeltaBetween()

◆ getFinishedId()

◆ getInputPort()

◆ getLocalInputPorts()

◆ getLocalOutputPorts()

◆ getNbOfElementsToBeProcessed()

◆ getNumberOfInputPorts()

◆ getOutPort()

◆ getOutputPort()

◆ getOutputPortType()

◆ getPassedResults()

◆ getProcessedData()

◆ getProgress()

◆ getProgressWeight()

◆ getReadyTasks()

◆ getSetOfInputPort()

◆ init()

◆ InterceptorizeNameOfPort()

◆ prepareSequenceValues()

◆ pushAllSequenceValues()

◆ releaseDelegateOf()

◆ resetState()

◆ selectRunnableTasks()

◆ setProcessedData()

◆ storeOutValsInSeqForOutOfScopeUse()

◆ typeName()

◆ updateStateForFinalizeNodeOnFinishedEventFrom()

◆ updateStateForInitNodeOnFinishedEventFrom()

◆ updateStateForWorkNodeOnFinishedEventFrom()

◆ updateStateOnFailedEventFrom()

◆ updateStateOnFinishedEventFrom()

◆ writeDot()

Friends And Related Function Documentation

◆ FakeNodeForForEachLoop

◆ SplitterNode

Member Data Documentation

◆ _currentIndex

◆ _execCurrentId

◆ _execOutGoingPorts

◆ _execVals

◆ _intecptrsForOutGoingPorts

◆ _nodeForSpecialCases

◆ _outGoingPorts

◆ _passedData

◆ _splitterNode

◆ INTERCEPTOR_STR

◆ NAME_OF_SPLITTERNODE

◆ NOT_RUNNING_BRANCH_ID