Composed node to group elementary and composed nodes. More...

#include <Bloc.hxx>

Inheritance diagram for YACS::ENGINE::Bloc:

[legend]

Collaboration diagram for YACS::ENGINE::Bloc:

[legend]

Public Member Functions
	Bloc (const Bloc &other, ComposedNode *father, bool editionOnly)

	Bloc (const std::string &name)
	Create a Bloc node with a given name. More...

virtual	~Bloc ()

bool	isFinished ()
	Indicate if the bloc execution is finished. More...

int	getNumberOfCFLinks () const

void	init (bool start=true)
	Initialize the bloc. More...

void	getReadyTasks (std::vector< Task * > &tasks)
	Collect all nodes that are ready to execute. More...

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

bool	edAddChild (Node *DISOWNnode)
	Add a child node to the bloc. More...

void	edRemoveChild (Node *node)

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

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

std::vector< std::list< Node * > >	splitIntoIndependantGraph () const

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

virtual void	writeDot (std::ostream &os) const
	Dump to the input stream a dot representation of the node. More...

void	accept (Visitor *visitor)

template<bool direction>
void	findAllPathsStartingFrom (Node start, std::list< std::vector< Node > > &vec, std::map< Node , std::set< Node > > &accelStr) const

template<bool direction>
void	findAllNodesStartingFrom (Node start, std::set< Node > &result, std::map< Node , std::set< Node > > &accelStr, LinkInfo &info) const

virtual std::string	typeName ()

int	getMaxLevelOfParallelism () const

void	getWeightRegardingDPL (ComplexWeight *weight)

void	removeRecursivelyRedundantCL ()

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

void	fitToPlayGround (const PlayGround *pg)

void	propagePlayGround (const PlayGround *pg)

Public Member Functions inherited from YACS::ENGINE::StaticDefinedComposedNode
bool	isPlacementPredictableB4Run () const

bool	isMultiplicitySpecified (unsigned &value) const

void	forceMultiplicity (unsigned value)

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

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

bool	isFinished ()

void	init (bool start=true)

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

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

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)

virtual bool	isPlacementPredictableB4Run () const =0

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

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

virtual bool	edAddChild (Node *DISOWNnode)

virtual void	edRemoveChild (Node *node)
	Remove a child node. 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 bool	isLoop () const

virtual std::list< Node * >	edGetDirectDescendants () const =0

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::list< ProgressWeight >	getProgressWeight () const
	Get the progress weight for all elementary nodes. More...

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

std::string	getOutPortName (const OutPort *) const

int	getNumberOfInputPorts () const

int	getNumberOfOutputPorts () const

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

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

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

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

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

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

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

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

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 std::string	typeName ()

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

virtual void	checkBasicConsistency () const

virtual std::string	getErrorReport ()
	returns a string that contains an error report if the node is in error 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 ()

void	accept (Visitor *visitor)

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

virtual std::string	getProgress () const

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

virtual void	init (bool start=true)

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

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

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	writeDot (std::ostream &os) const
	Dump to the input stream a dot representation of the node. More...

void	writeDotInFile (const std::string &fileName) const

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

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

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

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

virtual std::list< ElementaryNode * >	getRecursiveConstituents () const =0

virtual std::list< ProgressWeight >	getProgressWeight () const =0

virtual int	getNumberOfInputPorts () const =0

virtual int	getNumberOfOutputPorts () const =0

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

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

virtual std::list< InputPort * >	getSetOfInputPort () const =0

virtual std::list< OutputPort * >	getSetOfOutputPort () const =0

virtual std::list< InputPort * >	getLocalInputPorts () const =0

virtual std::list< OutputPort * >	getLocalOutputPorts () const =0

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

virtual std::string	getInPortName (const InPort *) const =0

virtual std::string	getOutPortName (const OutPort *) const =0

virtual std::list< InputDataStreamPort * >	getSetOfInputDataStreamPort () const =0

virtual std::list< OutputDataStreamPort * >	getSetOfOutputDataStreamPort () const =0

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

InPropertyPort *	getInPropertyPort () const

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

virtual std::set< OutPort * >	getAllOutPortsLeavingCurrentScope () const =0

virtual std::set< InPort * >	getAllInPortsComingFromOutsideOfCurrentScope () const =0

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

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

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

virtual OutputPort *	getOutputPort (const std::string &name) const =0

virtual InputDataStreamPort *	getInputDataStreamPort (const std::string &name) const =0

virtual OutputDataStreamPort *	getOutputDataStreamPort (const std::string &name) const =0

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

virtual ComposedNode *	getRootNode () 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 Node *	getChildByName (const std::string &name) const =0

virtual Proc *	getProc ()

virtual const Proc *	getProc () const

virtual void	accept (Visitor *visitor)=0

virtual int	getMaxLevelOfParallelism () const =0

virtual void	getWeightRegardingDPL (ComplexWeight *weight)=0

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

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

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 void	edUpdateState ()
	update the status of the node More...

virtual std::string	getErrorReport ()
	returns a string that contains an error report if the node is in error 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)

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

Public Member Functions inherited from YACS::ENGINE::Scheduler
virtual void	init (bool start=true)=0

virtual bool	isFinished ()=0

virtual void	exUpdateState ()=0

virtual std::string	getName () const =0

virtual std::string	getTaskName (Task *task) const =0

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

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

virtual void	notifyFrom (const Task sender, YACS::Event event, const Executor execInst)=0

virtual DeploymentTree	getDeploymentTree () const =0

virtual bool	isPlacementPredictableB4Run () const =0

virtual bool	isMultiplicitySpecified (unsigned &value) const =0

virtual void	forceMultiplicity (unsigned value)=0

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

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

virtual	~Scheduler ()

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

bool	areAllSubNodesFinished () const

bool	areAllSubNodesDone () const

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

void	checkNoCyclePassingThrough (Node *node)

std::vector< std::pair< OutGate , InGate > >	getSetOfInternalCFLinks () const

YACS::Event	updateStateOnFinishedEventFrom (Node *node)

YACS::Event	updateStateOnFailedEventFrom (Node node, const Executor execInst)
	Notify this bloc that a node has failed. More...

void	initComputation () const

void	performCFComputationsOnlyOneLevel (LinkInfo &info) const

void	performCFComputations (LinkInfo &info) const

void	destructCFComputations (LinkInfo &info) const
	destroy recursively all results of initial computations. 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

bool	areLinked (Node start, Node end, bool fw) const
	Check if two nodes are linked. More...

bool	arePossiblyRunnableAtSameTime (Node start, Node end) const
	Check if two nodes can run in parallel. More...

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

void	seekOkAndUseless1 (std::vector< Node * > &okAndUseless1, std::set< Node * > &allNodes) const

void	seekUseless2 (std::vector< Node * > &useless2, std::set< Node * > &allNodes) const

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

	StaticDefinedComposedNode (const StaticDefinedComposedNode &other, ComposedNode *father)

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

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

virtual Node *	getChildByShortName (const std::string &name) const =0

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 YACS::Event	updateStateOnFinishedEventFrom (Node *node)=0

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

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

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

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

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

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

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

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

virtual void	checkNoCyclePassingThrough (Node *node)=0

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

virtual 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 =0

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

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

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

	Node (const Node &other, ComposedNode *father)

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

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

virtual Node *	simpleClone (ComposedNode *father, bool editionOnly=true) const =0

virtual void	exForwardFailed ()

virtual void	exForwardFinished ()

virtual void	edDisconnectAllLinksWithMe ()

Static Protected Member Functions
static void	verdictForOkAndUseless1 (const std::map< Node , std::list< OutPort > > &pool, InputPort end, const std::vector< Node > &candidates, unsigned char &alreadyFed, bool direction, LinkInfo &info)

static void	verdictForCollapses (const std::map< Node , std::list< OutPort > > &pool, InputPort end, const std::set< Node > &candidates, unsigned char &alreadyFed, bool direction, LinkInfo &info)

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)

Protected Attributes
std::list< Node * >	_setOfNode

std::map< Node , std::set< Node > > *	_fwLinks
	For internal calculations. More...

std::map< Node , std::set< Node > > *	_bwLinks
	For internal calculations. More...

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

Private Member Functions
std::list< AbstractPoint * >	analyzeParallelism () const

Static Private Member Functions
static void	findUselessLinksIn (const std::list< std::vector< Node * > > &res, LinkInfo &info)

template<bool direction>
static unsigned	appendIfAlreadyFound (std::list< std::vector< Node * > > &res, const std::vector< Node * > &startRes, Node node, std::map< Node , std::set< Node * > > &fastFinder)

static void	updateWithNewFind (const std::vector< Node * > &path, std::map< Node , std::set< Node > > &fastFinder)

Additional Inherited Members
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)

Public Attributes inherited from YACS::ENGINE::Node
YACS::Colour	_colour

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

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

Detailed Description

Composed node to group elementary and composed nodes.

Definition at line 35 of file Bloc.hxx.

Constructor & Destructor Documentation

◆ Bloc() [1/2]

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

Definition at line 48 of file Bloc.cxx.

                                                                   :StaticDefinedComposedNode(other,father),_fwLinks(0),_bwLinks(0)
{
  for(list<Node *>::const_iterator iter=other._setOfNode.begin();iter!=other._setOfNode.end();iter++)
    _setOfNode.push_back((*iter)->simpleClone(this,editionOnly));
 
  //CF Linking
  vector< pair<OutGate *, InGate *> > cfLinksToReproduce=other.getSetOfInternalCFLinks();
  vector< pair<OutGate *, InGate *> >::iterator iter1=cfLinksToReproduce.begin();
  for(;iter1!=cfLinksToReproduce.end();iter1++)
    edAddCFLink(getChildByName(other.getChildName((*iter1).first->getNode())),getChildByName(other.getChildName((*iter1).second->getNode())));
 
  //Data + DataStream linking
  vector< pair<OutPort *, InPort *> > linksToReproduce=other.getSetOfInternalLinks();
  vector< pair<OutPort *, InPort *> >::iterator iter2=linksToReproduce.begin();
  for(;iter2!=linksToReproduce.end();iter2++)
    {
      OutPort* pout = iter2->first;
      InPort* pin = iter2->second;
      if(&other == getLowestCommonAncestor(pout->getNode(), pin->getNode()))
      {
        edAddLink(getOutPort(other.getPortName(pout)),getInPort(other.getPortName(pin)));
      }
    }
}

References _setOfNode, YACS::ENGINE::ComposedNode::edAddCFLink(), YACS::ENGINE::ComposedNode::edAddLink(), YACS::ENGINE::ComposedNode::getChildByName(), YACS::ENGINE::ComposedNode::getChildName(), YACS::ENGINE::Node::getInPort(), YACS::ENGINE::ComposedNode::getLowestCommonAncestor(), YACS::ENGINE::Port::getNode(), YACS::ENGINE::ComposedNode::getOutPort(), YACS::ENGINE::ComposedNode::getPortName(), getSetOfInternalCFLinks(), and YACS::ENGINE::ComposedNode::getSetOfInternalLinks().

◆ Bloc() [2/2]

Bloc::Bloc ( const std::string & name )

Create a Bloc node with a given name.

Parameters

name	: the given name

Definition at line 77 of file Bloc.cxx.

                               :StaticDefinedComposedNode(name),_fwLinks(0),_bwLinks(0)
{
}

◆ ~Bloc()

Bloc::~Bloc ( )

virtual

Definition at line 81 of file Bloc.cxx.

{
  for(list<Node *>::iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
    delete *iter;
  delete _fwLinks;
  delete _bwLinks;
}

References _bwLinks, _fwLinks, and _setOfNode.

Member Function Documentation

◆ accept()

void Bloc::accept ( Visitor * visitor )

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::Proc.

Definition at line 447 of file Bloc.cxx.

{
  visitor->visitBloc(this);
}

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

Referenced by fitToPlayGround(), and propagePlayGround().

◆ analyzeParallelism()

std::list< AbstractPoint * > Bloc::analyzeParallelism ( ) const

private

Definition at line 463 of file Bloc.cxx.

{
  std::vector< std::list<Node *> > r(splitIntoIndependantGraph());
  std::list< AbstractPoint * > pts;
  for(std::vector< std::list<Node *> >::const_iterator it=r.begin();it!=r.end();it++)
    {
      SetOfPoints sop(*it);
      sop.simplify();
      pts.push_back(sop.getUniqueAndReleaseIt());
    }
  return pts;
}

References YACS::ENGINE::SetOfPoints::getUniqueAndReleaseIt(), testCppPluginInvokation::r, YACS::ENGINE::SetOfPoints::simplify(), and splitIntoIndependantGraph().

Referenced by getMaxLevelOfParallelism(), getWeightRegardingDPL(), and partitionRegardingDPL().

◆ appendIfAlreadyFound()

template<bool direction>

unsigned YACS::ENGINE::Bloc::appendIfAlreadyFound	(	std::list< std::vector< Node * > > &	res,
		const std::vector< Node * > &	startRes,
		Node *	node,
		std::map< Node , std::set< Node > > &	fastFinder
	)

staticprivate

Internal method for CF computation. Given 'fastFinder' it searched 'node' to see if an already found path in 'res' go through 'node'. If true all paths are deduced and append to res and 'fastFinder' is updated for next turn.

Definition at line 135 of file Bloc.hxx.

    {
      std::map<Node *, std::set<Node *> >::iterator iter=fastFinder.find(node);
      if(iter==fastFinder.end())
        return 0;
      unsigned ret=0;
      std::vector<std::pair<std::set<Node *>::iterator, std::set<Node *>::iterator > > li;
      std::pair<std::set<Node *>::iterator, std::set<Node *>::iterator> ipr(((*iter).second).begin(),((*iter).second).end());
      li.push_back(ipr);
      std::vector<Node *> work(startRes);
      std::list< std::vector<Node *> >::iterator where=res.end(); where--;
      std::list< std::vector<Node *> >::iterator updates=where;
      while(!li.empty())
        {
          if(li.back().first!=li.back().second)
            {
              work.push_back(*(li.back().first));
              if(CFDirectionVisTraits<direction>::getNexts(work.back()).empty())
                {
                  where=res.insert(where,work);
                  ret++;
                  li.back().first++;
                  work.pop_back();
                }
              else
                {
                  std::set<Node *>& s=fastFinder[*(li.back().first)];
                  std::pair<std::set<Node *>::iterator, std::set<Node *>::iterator> pr(s.begin(),s.end());
                  li.push_back(pr);
                }
            }
          else
            {
              work.pop_back();
              li.pop_back();
              if(!li.empty())
                li.back().first++;
            }
        }
      updates--;
      for(unsigned i=0;i<ret;i++,updates--)
        updateWithNewFind(*updates,fastFinder);
      return ret;
    }

References yacsorb.CORBAEngineTest::i, and updateWithNewFind().

◆ areAllSubNodesDone()

bool Bloc::areAllSubNodesDone ( ) const

protected

Definition at line 288 of file Bloc.cxx.

{
  for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
    {
      if((*iter)->_state == YACS::DONE)continue;
      if((*iter)->_state == YACS::DISABLED)continue;
      return false;
    }
  return true;
}

References _setOfNode, YACS::DISABLED, and YACS::DONE.

Referenced by updateStateOnFailedEventFrom(), and updateStateOnFinishedEventFrom().

◆ areAllSubNodesFinished()

bool Bloc::areAllSubNodesFinished ( ) const

protected

Definition at line 299 of file Bloc.cxx.

{
  for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
    {
      if((*iter)->_state == YACS::DONE)continue;
      if((*iter)->_state == YACS::FAILED)continue;
      if((*iter)->_state == YACS::DISABLED)continue;
      if((*iter)->_state == YACS::ERROR)continue;
      if((*iter)->_state == YACS::INTERNALERR)continue;
      return false;
    }
  return true;
}

References _setOfNode, YACS::DISABLED, YACS::DONE, YACS::ERROR, YACS::FAILED, and YACS::INTERNALERR.

Referenced by updateStateOnFailedEventFrom(), and updateStateOnFinishedEventFrom().

◆ areLinked()

bool Bloc::areLinked	(	Node *	start,
		Node *	end,
		bool	fw
	)		const

protected

Check if two nodes are linked.

'start' and 'end' must be direct son of 'this'. Typically used for data link.

Parameters

start	: start node
end	: end node
fw	indicates if it is a forward link searched (true : default value) or a backward link serach.

Returns: if true or false

Definition at line 650 of file Bloc.cxx.

{
  set<Node *>& nexts=fw ? (*_fwLinks)[start] : (*_bwLinks)[start];
  return nexts.find(end)!=nexts.end();
}

Referenced by checkControlDependancy().

◆ arePossiblyRunnableAtSameTime()

bool Bloc::arePossiblyRunnableAtSameTime	(	Node *	start,
		Node *	end
	)		const

protected

Check if two nodes can run in parallel.

Typically used for stream link. 'start' and 'end' must be direct son of 'this'.

Parameters

start	: start node
end	: end node

Returns: true or false

Definition at line 664 of file Bloc.cxx.

{
  set<Node *>& nexts=(*_fwLinks)[start];
  set<Node *>& preds=(*_bwLinks)[start];
  return nexts.find(end)==nexts.end() && preds.find(end)==preds.end();
}

Referenced by checkControlDependancy().

◆ checkCFLinks()

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

protectedvirtual

Check control flow links.

Parameters

starts	If different of 0, must aggregate at leat 1 element.
end	: end port
alreadyFed	in/out parameter. Indicates if 'end' ports is already and surely set or fed by an another port.
direction	If true : forward direction else backward direction.
info	: collected information

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 679 of file Bloc.cxx.

{
  if(alreadyFed==FREE_ST || alreadyFed==FED_ST)
    {
      map<Node *,list <OutPort *> > classPerNodes;
      for(list< OutPort *>::const_iterator iter1=starts.begin();iter1!=starts.end();iter1++)
        classPerNodes[isInMyDescendance((*iter1)->getNode())].push_back(*iter1);
      set<Node *> allNodes;
      for(map<Node *,list <OutPort *> >::iterator iter2=classPerNodes.begin();iter2!=classPerNodes.end();iter2++)
        allNodes.insert((*iter2).first);
      vector<Node *> okAndUseless1,useless2;
      seekOkAndUseless1(okAndUseless1,allNodes);
      seekUseless2(useless2,allNodes);//after this point allNodes contains collapses
      verdictForOkAndUseless1(classPerNodes,end,okAndUseless1,alreadyFed,direction,info);
      verdictForCollapses(classPerNodes,end,allNodes,alreadyFed,direction,info);
      verdictForOkAndUseless1(classPerNodes,end,useless2,alreadyFed,direction,info);
    }
  else if(alreadyFed==FED_DS_ST)
    for(list< OutPort *>::const_iterator iter1=starts.begin();iter1!=starts.end();iter1++)
      info.pushErrLink(*iter1,end,E_COLLAPSE_DFDS);
}

References YACS::ENGINE::E_COLLAPSE_DFDS, YACS::ENGINE::ComposedNode::FED_DS_ST, YACS::ENGINE::ComposedNode::FED_ST, YACS::ENGINE::ComposedNode::FREE_ST, YACS::ENGINE::ComposedNode::isInMyDescendance(), YACS::ENGINE::LinkInfo::pushErrLink(), seekOkAndUseless1(), seekUseless2(), verdictForCollapses(), and verdictForOkAndUseless1().

Referenced by verdictForCollapses(), and verdictForOkAndUseless1().

◆ checkControlDependancy()

void Bloc::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

protectedvirtual

WARNING Needs call of performCFComputations before beeing called. Perform updates of containers regarding attributes of link 'start' -> 'end' and check the correct linking. The output is in info struct.

Parameters

start	: start port
end	: end port
cross	:
fw	out parameter being append if start -> end link is a forward link without cross type DF/DS.
fwCross	out parameter being append if start -> end link is a forward link with cross type DF/DS.
bw	out parameter being append if start -> end link is a backward link.
info	out parameter being informed about eventual errors.

Implements YACS::ENGINE::ComposedNode.

Definition at line 614 of file Bloc.cxx.

{
  if(!cross)
    {
      Node *startN=isInMyDescendance(start->getNode());
      Node *endN=isInMyDescendance(end->getNode());
      if(startN==endN)
        bw[(ComposedNode *)this].push_back(start);
      else if(areLinked(startN,endN,true))
        fw[(ComposedNode *)this].push_back(start);
      else
        if(areLinked(startN,endN,false))
          bw[(ComposedNode *)this].push_back(start);
        else
          info.pushErrLink(start,end,E_UNPREDICTABLE_FED);
    }
  else//DFDS detected
    if(arePossiblyRunnableAtSameTime(isInMyDescendance(start->getNode()),isInMyDescendance(end->getNode())))
      fwCross.push_back(start);
    else
      info.pushErrLink(start,end,E_DS_LINK_UNESTABLISHABLE);
}

References areLinked(), arePossiblyRunnableAtSameTime(), YACS::ENGINE::E_DS_LINK_UNESTABLISHABLE, YACS::ENGINE::E_UNPREDICTABLE_FED, YACS::ENGINE::Port::getNode(), YACS::ENGINE::ComposedNode::isInMyDescendance(), and YACS::ENGINE::LinkInfo::pushErrLink().

◆ checkNoCyclePassingThrough()

void Bloc::checkNoCyclePassingThrough ( Node * node )

protectedvirtual

Note: Checks that in the forest from 'node' there are NO back-edges. WARNING : When using this method 'node' has to be checked in order to be part of direct children of 'this'.

Implements YACS::ENGINE::ComposedNode.

Definition at line 338 of file Bloc.cxx.

{
  set<Node *> currentNodesToTest;
  //don't insert node to test in set. 
  //If it is present after insertion of connected nodes we have a loop
  //collect all connected nodes
  insertNodeChildrenInSet(node,currentNodesToTest);
  //try to insert node
  if(!(currentNodesToTest.insert(node)).second)
    throw Exception("Cycle has been detected",1);
}

References insertNodeChildrenInSet().

◆ destructCFComputations()

void Bloc::destructCFComputations ( LinkInfo & info ) const

protectedvirtual

destroy recursively all results of initial computations.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 594 of file Bloc.cxx.

{
  StaticDefinedComposedNode::destructCFComputations(info);
  delete _fwLinks; _fwLinks=0;
  delete _bwLinks; _bwLinks=0;
}

References _bwLinks, _fwLinks, and YACS::ENGINE::ComposedNode::destructCFComputations().

Referenced by removeRecursivelyRedundantCL().

◆ edAddChild()

bool Bloc::edAddChild ( Node * node )

virtual

Add a child node to the bloc.

Parameters

node	the node to add to the bloc

Returns: a boolean flag indicating if the node has been added

If node is already a direct child of current bloc, do nothing. If node is a child of another bloc, throw exception. If node name already used in bloc, throw exception. Publish inputPorts in current bloc and ancestors.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 176 of file Bloc.cxx.

{
  if(isNodeAlreadyAggregated(node))
    {
      if(node->_father==this)
        return false;
      else
        {
          string what = "Bloc::edAddChild : node "; what += node->getName();
          what += " is already grand children of node";
          throw Exception(what);
        }
    }
 
  if(node->_father)
    {
      string what = "Bloc::edAddChild: node is not orphan: "; what += node->getName();
      throw Exception(what);
    }
  
  checkNoCrossHierachyWith(node);
 
  if(isNameAlreadyUsed(node->getName()))
    {
      string what("Bloc::edAddChild : name "); what+=node->getName(); 
      what+=" already exists in the scope of "; what+=_name;
      throw Exception(what);
    }
  
  node->_father=this;
  _setOfNode.push_back(node);
  //should we also set _modified flag for node ??
  ComposedNode *iter=node->_father;
  //set the _modified flag so that latter on edUpdateState (eventually called by isValid) refresh state
  //better call it at end
  modified();
  return true;
}

References YACS::ENGINE::Node::_father, YACS::ENGINE::Node::_name, _setOfNode, YACS::ENGINE::ComposedNode::checkNoCrossHierachyWith(), YACS::ENGINE::Node::getName(), isNameAlreadyUsed(), YACS::ENGINE::ComposedNode::isNodeAlreadyAggregated(), and YACS::ENGINE::Node::modified().

Referenced by YACS::HMI::SubjectNode::registerUndoDestroy().

◆ edGetDirectDescendants()

std::list< Node * > YACS::ENGINE::Bloc::edGetDirectDescendants ( ) const

inlinevirtual

Implements YACS::ENGINE::ComposedNode.

Definition at line 58 of file Bloc.hxx.

58{ return _setOfNode; }

Referenced by YACS::HMI::GuiEditor::PutGraphInBloc().

◆ edRemoveChild()

void Bloc::edRemoveChild ( Node * node )

virtual

Remove 'node' from the set of direct children.

Exceptions

If	'node' is NOT the son of 'this'.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 220 of file Bloc.cxx.

{
  StaticDefinedComposedNode::edRemoveChild(node);
  list<Node *>::iterator iter=find(_setOfNode.begin(),_setOfNode.end(),node);
  if(iter!=_setOfNode.end())
    {
      _setOfNode.erase(iter);
      modified();
    }
}

References _setOfNode, YACS::ENGINE::ComposedNode::edRemoveChild(), and YACS::ENGINE::Node::modified().

◆ exUpdateState()

void Bloc::exUpdateState ( )

virtual

Update the bloc state.

Update the '_state' attribute. Typically called by 'this->_inGate' when 'this->_inGate' is ready. Contrary to Node::exUpdateState no check done on inputs because internal linked DF inputports are not valid yet.

Reimplemented from YACS::ENGINE::Node.

Definition at line 153 of file Bloc.cxx.

{
  if(_state == YACS::DISABLED)return;
  if(_state == YACS::DONE)return;
  if(_inGate.exIsReady())
    {
      setState(YACS::ACTIVATED);
      for(list<Node *>::iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
        if((*iter)->exIsControlReady())
          (*iter)->exUpdateState();
    }
}

References YACS::ENGINE::Node::_inGate, _setOfNode, YACS::ENGINE::Node::_state, YACS::ACTIVATED, YACS::DISABLED, YACS::DONE, YACS::ENGINE::InGate::exIsReady(), and YACS::ENGINE::Node::setState().

Referenced by YACS::ENGINE::loadState(), and main().

◆ findAllNodesStartingFrom()

template<bool direction>

void YACS::ENGINE::Bloc::findAllNodesStartingFrom	(	Node *	start,
		std::set< Node * > &	result,
		std::map< Node , std::set< Node > > &	accelStr,
		LinkInfo &	info
	)		const

Definition at line 181 of file Bloc.hxx.

    {
      std::list< std::vector<Node *> > li;
      findAllPathsStartingFrom<direction>(start,li,accelStr);
      for(std::list< std::vector<Node *> >::const_iterator iter=li.begin();iter!=li.end();iter++)
        for(std::vector<Node *>::const_iterator iter2=(*iter).begin()+1;iter2!=(*iter).end();iter2++)
          result.insert(*iter2);
      if(direction)
        findUselessLinksIn(li,info);
    }

References findUselessLinksIn().

Referenced by YACS::ENGINE::BagPoint::expandNonSimpleCaseOn().

◆ findAllPathsStartingFrom()

template<bool direction>

void YACS::ENGINE::Bloc::findAllPathsStartingFrom	(	Node *	start,
		std::list< std::vector< Node * > > &	vec,
		std::map< Node , std::set< Node > > &	accelStr
	)		const

Method for CF computation.DFS visitor is used. if direction is true forward visiting is performed, if false backward is performed.

Parameters

start	must be a direct descendant of 'this'.
vec	:
accelStr

Definition at line 201 of file Bloc.hxx.

    {
      initComputation();
      Node *current=start;
      int caseId=0;
      int idInCase=0;
      vec.push_back(std::vector<Node *>());
      typename CFDirectionVisTraits<direction>::Iterator iter;
      std::list< std::vector<Node *> >::iterator curLine=vec.begin();
      while(start->_colour!=YACS::Black)
        {
          (*curLine).push_back(current);
          idInCase++;
          //
          if(CFDirectionVisTraits<direction>::getNexts(current).empty())
            {
              
              vec.push_back(std::vector<Node *>((*curLine)));
              updateWithNewFind(*curLine,accelStr);
              current->_colour=YACS::Black;
              curLine++;
              if(idInCase>1)
                {
                  idInCase-=2;
                  current=(*curLine)[idInCase];
                  (*curLine).pop_back();
                  (*curLine).pop_back();
                }
              continue;
            }
          if(current->_colour==YACS::Black)
            {
              appendIfAlreadyFound<direction>(vec,(*curLine),current,accelStr);
              curLine=vec.end(); curLine--;
              current->_colour=YACS::Black;
              if(idInCase>1)
                {
                  idInCase-=2;
                  current=(*curLine)[idInCase];
                  (*curLine).pop_back();
                  (*curLine).pop_back();
                }
              continue;
            }
          for(iter=CFDirectionVisTraits<direction>::getNexts(current).begin();iter!=CFDirectionVisTraits<direction>::getNexts(current).end();iter++)
            if(!(*iter).second)
              break;
          if(iter==CFDirectionVisTraits<direction>::getNexts(current).end())
            {//Fail this branch should be forgotten go rev
              current->_colour=YACS::Black;
              (*curLine).pop_back();
              if(idInCase>1)
                {
                  idInCase-=2;
                  current=(*curLine)[idInCase];
                  (*curLine).pop_back();
                }
            }
          else
            {
              //Nothing to signal continuing in this direction hoping to find
              current=(*iter).first->getNode();
              (*iter).second=true;
            }
        }
      vec.pop_back();
    }

References YACS::ENGINE::Node::_colour, YACS::Black, initComputation(), and updateWithNewFind().

◆ findUselessLinksIn()

void Bloc::findUselessLinksIn	(	const std::list< std::vector< Node * > > &	res,
		LinkInfo &	info
	)

staticprivate

Internal method : After all paths have been found, useless CF links are searched

Definition at line 883 of file Bloc.cxx.

{
  unsigned maxSize=0;
  list< vector<Node *> >::const_iterator whereToPeerAt;
  for(list< vector<Node *> >::const_iterator iter=res.begin();iter!=res.end();iter++)
    if((*iter).size()>maxSize)
      {
        maxSize=(*iter).size();
        whereToPeerAt=iter;
      }
  //
  if(maxSize>1)
    {
      vector<Node *>::const_iterator iter2=(*whereToPeerAt).begin();
      map<Node *,bool>::iterator iter4;
      set<Node *> searcher(iter2+1,(*whereToPeerAt).end());//to boost research
      for(;iter2!=((*whereToPeerAt).end()-2);iter2++)
        {
          list< pair<InGate *,bool> >& nexts=(*iter2)->getOutGate()->edMapInGate();
          for(list< pair<InGate *,bool> >::iterator iter4=nexts.begin();iter4!=nexts.end();iter4++)
            if((*iter4).first->getNode()!=*(iter2+1))
              if(searcher.find((*iter4).first->getNode())!=searcher.end())
                info.pushUselessCFLink(*iter2,(*iter4).first->getNode());
          searcher.erase(*iter2);
        }
    }
}

References YACS::ENGINE::LinkInfo::pushUselessCFLink().

Referenced by findAllNodesStartingFrom().

◆ fitToPlayGround()

void Bloc::fitToPlayGround ( const PlayGround * pg )

Definition at line 31 of file Bloc_impl.cxx.

{
  static const char MSG[]="Bloc::fitToPlayGround : Not implemented yet for this type of node !";
  class MyVisitor : public Visitor
    {
    public:
      MyVisitor(ComposedNode *root):Visitor(root),_lev(0),_max_lev(0) { }
      void visitBloc(Bloc *node) { node->ComposedNode::accept(this); }
      void visitElementaryNode(ElementaryNode *node) { }
      void visitForEachLoop(ForEachLoop *node)
      {
        _max_lev=std::max(_max_lev,_lev);
        {
          _lev++;
          node->ComposedNode::accept(this);
          _lev--;
        }
        node->edGetNbOfBranchesPort()->edInit(1);
        if(_lev==_max_lev)
          {
          _fes.push_back(node);// locate all leaves ForEach
          }
        if(_lev==0)
          _max_lev=0;
        }
      void visitForEachLoopDyn(ForEachLoopDyn *node) { throw YACS::Exception(MSG); }
      void visitOptimizerLoop(OptimizerLoop *node) { throw YACS::Exception(MSG); }
      void visitDynParaLoop(DynParaLoop *node) { throw YACS::Exception(MSG); }
      void visitForLoop(ForLoop *node) { throw YACS::Exception(MSG); }
      void visitInlineNode(InlineNode *node)
      {
          Container *cont(node->getContainer());
          HomogeneousPoolContainer *cont2(dynamic_cast<HomogeneousPoolContainer *>(cont));
          if(!cont2)
            return ;
          _cont.push_back(cont2);
          _cont2.insert(cont2);
      }
      void visitInlineFuncNode(InlineFuncNode *node) { throw YACS::Exception(MSG); }
      void visitLoop(Loop *node) { throw YACS::Exception(MSG); }
      void visitProc(Proc *node) { node->ComposedNode::accept(this); }
      void visitServiceNode(ServiceNode *node) { throw YACS::Exception(MSG); }
      void visitServerNode(ServerNode *node) { throw YACS::Exception(MSG); }
      void visitServiceInlineNode(ServiceInlineNode *node) { throw YACS::Exception(MSG); }
      void visitSwitch(Switch *node) { throw YACS::Exception(MSG); }
      void visitWhileLoop(WhileLoop *node) { throw YACS::Exception(MSG); }
      void visitPresetNode(DataNode *node) { throw YACS::Exception(MSG); }
      void visitOutNode(DataNode *node) { throw YACS::Exception(MSG); }
      void visitStudyInNode(DataNode *node) { throw YACS::Exception(MSG); }
      void visitStudyOutNode(DataNode *node) { throw YACS::Exception(MSG); }
    public:
      std::list<ForEachLoop *> _fes;
      std::list< HomogeneousPoolContainer *> _cont;
      std::set< HomogeneousPoolContainer * > _cont2;
      int _lev;
      int _max_lev;
  };
  YACS::BASES::AutoRefCnt<PartDefinition> pd(new AllPartDefinition(pg));
  std::map<ComposedNode *,YACS::BASES::AutoRefCnt<PartDefinition> > zeMap;
  MyVisitor vis(this);
  this->accept(&vis);
  for(std::list<ForEachLoop *>::const_iterator it=vis._fes.begin();it!=vis._fes.end();it++)
    (*it)->edGetNbOfBranchesPort()->edInit(1);
  this->removeRecursivelyRedundantCL();
  if (this->getMaxLevelOfParallelism() > pg->getNumberOfCoresAvailable())
    throw YACS::Exception("Bloc::fitToPlayGround : Not enough cores available to run the calculation !");
  this->partitionRegardingDPL(pd,zeMap);
  this->accept(&vis);
  for(std::list<ForEachLoop *>::const_iterator it=vis._fes.begin();it!=vis._fes.end();it++)
    {
      std::map<ComposedNode *,YACS::BASES::AutoRefCnt<PartDefinition> >::iterator it2(zeMap.find(*it));
      if(it2==zeMap.end())
        throw YACS::Exception("Bloc::fitToPlayGround : internal error !");
      int maxLev((*it)->getExecNode()->getMaxLevelOfParallelism());
      int a((*it2).second->getNumberOfCoresConsumed());
      int res(a/maxLev);
      (*it)->edGetNbOfBranchesPort()->edInit(res);
    }
  for(std::set< HomogeneousPoolContainer * >::const_iterator it=vis._cont2.begin();it!=vis._cont2.end();it++)
    (*it)->setSizeOfPool(pg->getNumberOfWorkers((*it)->getNumberOfCoresPerWorker()));
  //FIXME
}

References gui.CONNECTOR::a, accept(), YACS::ENGINE::DynParaLoop::edGetNbOfBranchesPort(), YACS::ENGINE::InputPort::edInit(), YACS::ENGINE::InlineNode::getContainer(), getMaxLevelOfParallelism(), YACS::ENGINE::PlayGround::getNumberOfCoresAvailable(), YACS::ENGINE::PlayGround::getNumberOfWorkers(), MSG, partitionRegardingDPL(), removeRecursivelyRedundantCL(), and YACS::ENGINE::Node::Visitor.

◆ getChildByShortName()

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

virtual

Implements YACS::ENGINE::ComposedNode.

Definition at line 279 of file Bloc.cxx.

{
  for (list<Node *>::const_iterator iter = _setOfNode.begin(); iter != _setOfNode.end(); iter++)
    if ((*iter)->getName() == name)
      return (*iter);
  string what("node "); what+= name ; what+=" is not a child of Bloc "; what += getName();
  throw Exception(what);
}

References _setOfNode, and YACS::ENGINE::ComposedNode::getName().

Referenced by YACS::HMI::GuiEditor::PutGraphInBloc(), and YACS::HMI::GuiEditor::PutGraphInNode().

◆ getChildren()

std::list< Node * > YACS::ENGINE::Bloc::getChildren ( ) const

inline

Definition at line 57 of file Bloc.hxx.

57{ return _setOfNode; }

Referenced by YACS::ENGINE::ProcCataLoader::loadCata(), YACS::HMI::CommandPutInComposedNode::localExecute(), and writeDot().

◆ getMaxLevelOfParallelism()

int Bloc::getMaxLevelOfParallelism ( ) const

virtual

Returns the max level of parallelism is this. The max of parallelism is equal to the sum of the max parallelism level for all concurrent branches in this.

Implements YACS::ENGINE::Node.

Definition at line 456 of file Bloc.cxx.

{
  std::list< AbstractPoint * > pts(analyzeParallelism());
  ForkBlocPoint fbp(pts,NULL);
  return fbp.getMaxLevelOfParallelism();
}

References analyzeParallelism(), and YACS::ENGINE::ForkBlocPoint::getMaxLevelOfParallelism().

Referenced by fitToPlayGround().

◆ getNumberOfCFLinks()

int Bloc::getNumberOfCFLinks ( ) const

Definition at line 116 of file Bloc.cxx.

{
  int ret=0;
  for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
    ret+=(*iter)->getOutGate()->getNbOfInGatesConnected();
  return ret;
}

References _setOfNode.

◆ getReadyTasks()

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

virtual

Collect all nodes that are ready to execute.

Parameters

tasks : vector of tasks to collect ready nodes

Implements YACS::ENGINE::Node.

Definition at line 133 of file Bloc.cxx.

{
  /*
   * ComposedNode state goes to ACTIVATED when one of its child has been ACTIVATED
   * To change this uncomment the following line
   * Then the father node will go to ACTIVATED state before its child node
   */
  if(_state==YACS::TOACTIVATE ) setState(YACS::ACTIVATED);
  if(_state==YACS::TOACTIVATE || _state==YACS::ACTIVATED)
    for(list<Node *>::iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
      (*iter)->getReadyTasks(tasks);
}

References _setOfNode, YACS::ENGINE::Node::_state, YACS::ACTIVATED, YACS::ENGINE::Node::setState(), and YACS::TOACTIVATE.

◆ getSetOfInternalCFLinks()

std::vector< std::pair< OutGate *, InGate * > > Bloc::getSetOfInternalCFLinks ( ) const

protected

Definition at line 350 of file Bloc.cxx.

{
  vector< pair<OutGate *, InGate *> > ret;
  for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
    {
      list<InGate *> outCFLinksOfCurNode=(*iter)->_outGate.edSetInGate();
      for(list<InGate *>::iterator iter2=outCFLinksOfCurNode.begin();iter2!=outCFLinksOfCurNode.end();iter2++)
        ret.push_back(pair<OutGate *, InGate *>(&(*iter)->_outGate,*iter2));
    }
  return ret;
}

References _setOfNode.

Referenced by Bloc().

◆ getWeightRegardingDPL()

void Bloc::getWeightRegardingDPL ( ComplexWeight * weight )

virtual

Implements YACS::ENGINE::Node.

Definition at line 476 of file Bloc.cxx.

{
  std::list< AbstractPoint * > pts(analyzeParallelism());
  ForkBlocPoint fbp(pts,NULL);
  fbp.getWeightRegardingDPL(weight);
}

References analyzeParallelism(), and YACS::ENGINE::ForkBlocPoint::getWeightRegardingDPL().

◆ init()

void Bloc::init ( bool start = true )

virtual

Initialize the bloc.

Parameters

start : a boolean flag indicating the kind of initialization If start is true, it's a complete initialization with reinitialization of port values If start is false, there is no initialization of port values

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::SalomeProc.

Definition at line 95 of file Bloc.cxx.

{
  Node::init(start);
  for(list<Node *>::iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
    (*iter)->init(start);
}

References _setOfNode, and YACS::ENGINE::Node::init().

Referenced by YACS::ENGINE::SalomeProc::init(), YACS::ENGINE::loadState(), and main().

◆ initComputation()

void Bloc::initComputation ( ) const

protected

Definition at line 701 of file Bloc.cxx.

{
  for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
    {
      (*iter)->_colour=White;
      (*iter)->getInGate()->exReset();
      (*iter)->getOutGate()->exReset();
    }
}

References _setOfNode, and YACS::White.

Referenced by findAllPathsStartingFrom(), and removeRecursivelyRedundantCL().

◆ isFinished()

bool Bloc::isFinished ( )

virtual

Indicate if the bloc execution is finished.

The execution bloc is finished if all its child nodes are finished with or without error or if it is disabled (not to execute)

Implements YACS::ENGINE::Scheduler.

Definition at line 107 of file Bloc.cxx.

{
    if(_state==YACS::DONE)return true;
    if(_state==YACS::ERROR)return true;
    if(_state==YACS::FAILED)return true;
    if(_state==YACS::DISABLED)return true;
    return false;
}

References YACS::ENGINE::Node::_state, YACS::DISABLED, YACS::DONE, YACS::ERROR, and YACS::FAILED.

◆ isNameAlreadyUsed()

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

protectedvirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 313 of file Bloc.cxx.

{
  for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
    if((*iter)->getName()==name)
      return true;
  return false;
}

References _setOfNode.

Referenced by edAddChild().

◆ partitionRegardingDPL()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 495 of file Bloc.cxx.

{
  if(!pd)
    throw Exception("Bloc::partitionRegardingDPL : NULL pointer !");
  std::list< AbstractPoint * > pts(analyzeParallelism());
  ForkBlocPoint fbp(pts,NULL);
  fbp.partitionRegardingDPL(pd,zeMap);
}

References analyzeParallelism(), and YACS::ENGINE::ForkBlocPoint::partitionRegardingDPL().

Referenced by fitToPlayGround().

◆ performCFComputations()

void Bloc::performCFComputations ( LinkInfo & info ) const

protectedvirtual

Updates mutable structures _fwLinks and _bwLinks with the result of computation (CPU consuming method). _fwLinks is a map with a Node* as key and a set<Node*> as value. The set gives all nodes that are forwardly connected to the key node _bwLinks is a map for backward dependencies The method is : for all CF link (n1->n2) add n2 and _fwLinks[n2] in forward dependencies of n1 and _bwLinks[n1] add n1 and _bwLinks[n1] in backward dependencies of n2 and _fwLinks[n2] For useless links If a node is already in a forward dependency when adding and the direct link already exists so it's a useless link (see the code !)

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 588 of file Bloc.cxx.

{
  StaticDefinedComposedNode::performCFComputations(info);
  performCFComputationsOnlyOneLevel(info);
}

References YACS::ENGINE::ComposedNode::performCFComputations(), and performCFComputationsOnlyOneLevel().

◆ performCFComputationsOnlyOneLevel()

void Bloc::performCFComputationsOnlyOneLevel ( LinkInfo & info ) const

protected

Definition at line 504 of file Bloc.cxx.

{
  delete _fwLinks;//Normally useless
  delete _bwLinks;//Normally useless
  _fwLinks=new map<Node *,set<Node *> >;
  _bwLinks=new map<Node *,set<Node *> >;
 
  //a set to store all CF links : used to find fastly if two nodes are connected
  std::set< std::pair< Node*, Node* > > links;
 
  for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
    {
      Node* n1=*iter;
      std::list<InGate *> ingates=n1->getOutGate()->edSetInGate();
      for(std::list<InGate *>::const_iterator it2=ingates.begin();it2!=ingates.end();it2++)
        {
          //CF link : n1 -> (*it2)->getNode()
          Node* n2=(*it2)->getNode();
          links.insert(std::pair< Node*, Node* >(n1,n2));
          std::set<Node *> bwn1=(*_bwLinks)[n1];
          std::set<Node *> fwn1=(*_fwLinks)[n1];
          std::set<Node *> fwn2=(*_fwLinks)[n2];
          std::set<Node *> bwn2=(*_bwLinks)[n2];
          std::pair<std::set<Node*>::iterator,bool> ret;
          for(std::set<Node *>::const_iterator iter2=bwn1.begin();iter2!=bwn1.end();iter2++)
            {
              for(std::set<Node *>::const_iterator it3=fwn2.begin();it3!=fwn2.end();it3++)
                {
                  ret=(*_fwLinks)[*iter2].insert(*it3);
                  if(ret.second==false)
                    {
                      //dependency already exists (*iter2) -> (*it3) : if a direct link exists it's a useless one
                      if(links.find(std::pair< Node*, Node* >(*iter2,*it3)) != links.end())
                        info.pushUselessCFLink(*iter2,*it3);
                    }
                }
              ret=(*_fwLinks)[*iter2].insert(n2);
              if(ret.second==false)
                {
                  //dependency already exists (*iter2) -> n2 : if a direct link exists it's a useless one
                  if(links.find(std::pair< Node*, Node* >(*iter2,n2)) != links.end())
                    info.pushUselessCFLink(*iter2,n2);
                }
            }
          for(std::set<Node *>::const_iterator it3=fwn2.begin();it3!=fwn2.end();it3++)
            {
              ret=(*_fwLinks)[n1].insert(*it3);
              if(ret.second==false)
                {
                  //dependency already exists n1 -> *it3 : if a direct link exists it's a useless one
                  if(links.find(std::pair< Node*, Node* >(n1,*it3)) != links.end())
                    info.pushUselessCFLink(n1,*it3);
                }
            }
          ret=(*_fwLinks)[n1].insert(n2);
          if(ret.second==false)
            {
              //dependency already exists n1 -> n2 : it's a useless link
              info.pushUselessCFLink(n1,n2);
            }
 
          for(std::set<Node *>::const_iterator iter2=fwn2.begin();iter2!=fwn2.end();iter2++)
            {
              (*_bwLinks)[*iter2].insert(bwn1.begin(),bwn1.end());
              (*_bwLinks)[*iter2].insert(n1);
            }
          (*_bwLinks)[n2].insert(bwn1.begin(),bwn1.end());
          (*_bwLinks)[n2].insert(n1);
        }
    }
}

References _bwLinks, _fwLinks, _setOfNode, YACS::ENGINE::OutGate::edSetInGate(), YACS::ENGINE::Node::getOutGate(), and YACS::ENGINE::LinkInfo::pushUselessCFLink().

Referenced by performCFComputations(), and removeRecursivelyRedundantCL().

◆ propagePlayGround()

void Bloc::propagePlayGround ( const PlayGround * pg )

Definition at line 152 of file Bloc_impl.cxx.

{
  MyVisitorPropagate vis(this);
  this->accept(&vis);
  for(auto cont : vis._cont2)
    cont->assignPG(pg);
}

References MyVisitorPropagate::_cont2, and accept().

◆ removeRecursivelyRedundantCL()

void Bloc::removeRecursivelyRedundantCL ( )

virtual

This method recursively all redundant control links in this.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 483 of file Bloc.cxx.

{
  StaticDefinedComposedNode::removeRecursivelyRedundantCL();
  LinkInfo info(I_CF_USELESS);
  initComputation();
  performCFComputationsOnlyOneLevel(info);
  std::set< std::pair<Node *, Node *> > linksToKill(info.getInfoUselessLinks());
  for(std::set< std::pair<Node *, Node *> >::const_iterator it=linksToKill.begin();it!=linksToKill.end();it++)
    edRemoveCFLink((*it).first,(*it).second);
  destructCFComputations(info);
}

References destructCFComputations(), YACS::ENGINE::ComposedNode::edRemoveCFLink(), YACS::ENGINE::LinkInfo::getInfoUselessLinks(), YACS::ENGINE::I_CF_USELESS, initComputation(), performCFComputationsOnlyOneLevel(), and YACS::ENGINE::ComposedNode::removeRecursivelyRedundantCL().

Referenced by fitToPlayGround().

◆ seekOkAndUseless1()

void Bloc::seekOkAndUseless1	(	std::vector< Node * > &	okAndUseless1,
		std::set< Node * > &	allNodes
	)		const

protected

WARNING use this method only after having called Bloc::performCFComputations method.

Parameters

okAndUseless1	out param contains at the end, the nodes without any collapse.
allNodes	in/out param. At the end, all the nodes in 'okAndUseless1' are deleted from 'allNodes'.

Definition at line 816 of file Bloc.cxx.

{
  set<Node *>::iterator iter=allNodes.begin();
  while(iter!=allNodes.end())
    {
      set<Node *>& whereToFind=(*_bwLinks)[*iter];
      std::set<Node *>::iterator iter2;
      for(iter2=allNodes.begin();iter2!=allNodes.end();iter2++)
        if((*iter)!=(*iter2))
          if(whereToFind.find(*iter2)==whereToFind.end())
            break;
      if(iter2!=allNodes.end())
        iter++;
      else
        {
          okAndUseless1.push_back((*iter));
          allNodes.erase(iter);
          iter=allNodes.begin();
        }
    }
}

Referenced by checkCFLinks().

◆ seekUseless2()

void Bloc::seekUseless2	(	std::vector< Node * > &	useless2,
		std::set< Node * > &	allNodes
	)		const

protected

WARNING use this method only after having called Bloc::performCFComputations method. For params see Bloc::seekOkAndUseless1.

Definition at line 842 of file Bloc.cxx.

{
  set<Node *>::iterator iter=allNodes.begin();
  while(iter!=allNodes.end())
    {
      set<Node *>& whereToFind=(*_fwLinks)[*iter];
      std::set<Node *>::iterator iter2;
      for(iter2=allNodes.begin();iter2!=allNodes.end();iter2++)
        if((*iter)!=(*iter2))
          if(whereToFind.find(*iter2)==whereToFind.end())
            break;
      if(iter2!=allNodes.end())
        {
          iter++;
        }
      else
        {
          useless2.push_back((*iter));
          allNodes.erase(iter);
          iter=allNodes.begin();
        }
    }
}

Referenced by checkCFLinks().

◆ simpleClone()

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

protectedvirtual

Implements YACS::ENGINE::Node.

Definition at line 124 of file Bloc.cxx.

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

References YACS::ENGINE::ComposedNode::Bloc.

◆ splitIntoIndependantGraph()

std::vector< std::list< Node * > > Bloc::splitIntoIndependantGraph ( ) const

Definition at line 231 of file Bloc.cxx.

{
  std::size_t sz(_setOfNode.size());
  list<Node *>::const_iterator it=_setOfNode.begin();
  for(;it!=_setOfNode.end();it++)
    (*it)->_colour=White;
  it=_setOfNode.begin();
  std::vector< list<Node *> > ret;
  while(it!=_setOfNode.end())
    {
      Node *start(*it); start->_colour=Grey;
      ret.push_back(list<Node *>());
      list<Node *>& ll(ret.back());
      std::queue<Node *> fifo; fifo.push(start);
      while(!fifo.empty())
        {
          Node *cur(fifo.front()); fifo.pop();
          ll.push_back(cur);
          //
          OutGate *og(cur->getOutGate());
          list<InGate *> og2(og->edSetInGate());
          for(list<InGate *>::const_iterator it2=og2.begin();it2!=og2.end();it2++)
            {
              Node *cur2((*it2)->getNode());
              if(cur2->_colour==White)
                {
                  cur2->_colour=Grey;
                  fifo.push(cur2);
                }
            }
          //
          InGate *ig(cur->getInGate());
          list<OutGate *> bl(ig->getBackLinks());
          for(list<OutGate *>::const_iterator it3=bl.begin();it3!=bl.end();it3++)
            {
              Node *cur3((*it3)->getNode());
              if(cur3->_colour==White)
                {
                  cur3->_colour=Grey;
                  fifo.push(cur3);
                }
            }
        }
      for(it=_setOfNode.begin();it!=_setOfNode.end() && (*it)->_colour!=White;it++);
    }
  return ret;
}

References YACS::ENGINE::Node::_colour, _setOfNode, YACS::ENGINE::OutGate::edSetInGate(), YACS::ENGINE::InGate::getBackLinks(), YACS::ENGINE::Node::getInGate(), YACS::ENGINE::Node::getOutGate(), YACS::Grey, and YACS::White.

Referenced by analyzeParallelism().

◆ typeName()

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

inlinevirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::Proc, and YACS::ENGINE::SalomeProc.

Definition at line 67 of file Bloc.hxx.

67{ return "YACS__ENGINE__Bloc"; }

◆ updateStateOnFailedEventFrom()

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

protectedvirtual

Notify this bloc that a node has failed.

Parameters

node	: node that has emitted the event

Returns: the event to notify to bloc's father

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 408 of file Bloc.cxx.

{
  node->exForwardFailed();
  if(areAllSubNodesFinished())
    {
      setState(YACS::DONE);
      if(!areAllSubNodesDone()){
          setState(YACS::FAILED);
          return YACS::ABORT;
      }
      return YACS::FINISH;//notify to father node that 'this' has becomed finished.
    }
  return YACS::NOEVENT;
}

References YACS::ABORT, areAllSubNodesDone(), areAllSubNodesFinished(), YACS::DONE, YACS::ENGINE::Node::exForwardFailed(), YACS::FAILED, YACS::FINISH, YACS::NOEVENT, and YACS::ENGINE::Node::setState().

◆ updateStateOnFinishedEventFrom()

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

protectedvirtual

Note: : Runtime called method. Indirectly called by StaticDefinedComposedNode::updateStateFrom which has dispatch to this method 'when event == FINISH'. WARNING Precondition : '_state == Running' and 'node->_father==this'(garanteed by StaticDefinedComposedNode::notifyFrom)

Calls the node's outgate OutGate::exNotifyDone if all nodes are not finished

Implements YACS::ENGINE::ComposedNode.

Definition at line 370 of file Bloc.cxx.

{
  DEBTRACE("Bloc::updateStateOnFinishedEventFrom: " << node->getName());
  //ASSERT(node->_father==this)
  if(areAllSubNodesFinished())
    {
      setState(YACS::DONE);
      if(!areAllSubNodesDone())
        {
          setState(YACS::FAILED);
          return YACS::ABORT;
        }
      return YACS::FINISH;//notify to father node that 'this' has becomed finished.
    }
  //more job to do in 'this' bloc
  //Conversion exceptions can be thrown so catch them to control errors
  try
    {
      //notify the finished node to propagate to its following nodes
      node->exForwardFinished();
    }
  catch(YACS::Exception& ex)
    {
      //The node has failed to propagate. It must be put in error
      DEBTRACE("Bloc::updateStateOnFinishedEventFrom: " << ex.what());
      // notify the node it has failed
      node->exForwardFailed();
      setState(YACS::FAILED);
      return YACS::ABORT;
    }
  return YACS::NOEVENT;//no notification to father needed because from father point of view nothing happened.
}

References YACS::ABORT, areAllSubNodesDone(), areAllSubNodesFinished(), DEBTRACE, YACS::DONE, testCppPluginInvokation::ex, YACS::ENGINE::Node::exForwardFailed(), YACS::ENGINE::Node::exForwardFinished(), YACS::FAILED, YACS::FINISH, YACS::ENGINE::Node::getName(), YACS::NOEVENT, and YACS::ENGINE::Node::setState().

◆ updateWithNewFind()

void Bloc::updateWithNewFind	(	const std::vector< Node * > &	path,
		std::map< Node , std::set< Node > > &	fastFinder
	)

staticprivate

Internal method : Given a succeful path : updates 'fastFinder'

Definition at line 869 of file Bloc.cxx.

{
  if(path.size()>=3)
    {
      vector<Node *>::const_iterator iter=path.begin(); iter++;
      vector<Node *>::const_iterator iter2=path.end(); iter2-=1;
      for(;iter!=iter2;iter++)
        fastFinder[*iter].insert(*(iter+1));
    }
}

Referenced by appendIfAlreadyFound(), and findAllPathsStartingFrom().

◆ verdictForCollapses()

void Bloc::verdictForCollapses	(	const std::map< Node , std::list< OutPort > > &	pool,
		InputPort *	end,
		const std::set< Node * > &	candidates,
		unsigned char &	alreadyFed,
		bool	direction,
		LinkInfo &	info
	)

staticprotected

Part of final step for CF graph anylizing. This is the part of collapses nodes.

Parameters

pool	:
end	:
candidates	:
alreadyFed	in/out parameter. Indicates if 'end' ports is already and surely set or fed by an another port.
direction
info	: collected information

Definition at line 765 of file Bloc.cxx.

{
  info.startCollapseTransac();
  for(set<Node *>::const_iterator iter=candidates.begin();iter!=candidates.end();iter++)
    {
      const list<OutPort *>& mySet=(*pool.find(*iter)).second;
      if(mySet.size()==1)
        {
          if(alreadyFed==FREE_ST)
            info.pushWarnLink(*(mySet.begin()),end,direction ? W_COLLAPSE : W_BACK_COLLAPSE);
          else if(alreadyFed==FED_ST)
            info.pushWarnLink(*(mySet.begin()),end,direction ? W_COLLAPSE_AND_USELESS : W_BACK_COLLAPSE_EL_AND_USELESS);
        }
      else
        {
          if(dynamic_cast<ElementaryNode *>(*iter))
            {
              WarnReason reason;
              if(alreadyFed==FREE_ST)
                reason=direction ? W_COLLAPSE_EL : W_BACK_COLLAPSE_EL;
              else if(alreadyFed==FED_ST)
                reason=direction ? W_COLLAPSE_EL_AND_USELESS : W_BACK_COLLAPSE_EL_AND_USELESS;
              for(list<OutPort *>::const_iterator iter2=mySet.begin();iter2!=mySet.end();iter2++)    
                info.pushWarnLink(*iter2,end,reason);
            }
          else
            {
              ((ComposedNode *)(*iter))->checkCFLinks(mySet,end,alreadyFed,direction,info);//Thanks to recursive model!
              WarnReason reason;
              if(alreadyFed==FREE_ST)
                reason=direction ? W_COLLAPSE : W_BACK_COLLAPSE;
              else if(alreadyFed==FED_ST)
                reason=direction ? W_COLLAPSE_AND_USELESS : W_BACK_COLLAPSE_AND_USELESS;
              for(list<OutPort *>::const_iterator iter2=mySet.begin();iter2!=mySet.end();iter2++)    
                info.pushWarnLink(*iter2,end,reason);
            }
        }
    }
  if(!candidates.empty())
    if(alreadyFed==FREE_ST)
      alreadyFed=FED_ST;
  info.endCollapseTransac();
}

References checkCFLinks(), YACS::ENGINE::LinkInfo::endCollapseTransac(), YACS::ENGINE::ComposedNode::FED_ST, YACS::ENGINE::ComposedNode::FREE_ST, YACS::ENGINE::LinkInfo::pushWarnLink(), YACS::ENGINE::LinkInfo::startCollapseTransac(), YACS::ENGINE::W_BACK_COLLAPSE, YACS::ENGINE::W_BACK_COLLAPSE_AND_USELESS, YACS::ENGINE::W_BACK_COLLAPSE_EL, YACS::ENGINE::W_BACK_COLLAPSE_EL_AND_USELESS, YACS::ENGINE::W_COLLAPSE, YACS::ENGINE::W_COLLAPSE_AND_USELESS, YACS::ENGINE::W_COLLAPSE_EL, and YACS::ENGINE::W_COLLAPSE_EL_AND_USELESS.

Referenced by checkCFLinks().

◆ verdictForOkAndUseless1()

void Bloc::verdictForOkAndUseless1	(	const std::map< Node , std::list< OutPort > > &	pool,
		InputPort *	end,
		const std::vector< Node * > &	candidates,
		unsigned char &	alreadyFed,
		bool	direction,
		LinkInfo &	info
	)

staticprotected

Part of final step for CF graph anylizing. This is the part of non collapse nodes.

Parameters

pool	:
end	:
candidates	:
alreadyFed	in/out parameter. Indicates if 'end' ports is already and surely set or fed by an another port.
direction
info	: collected information

Definition at line 720 of file Bloc.cxx.

{
  for(vector<Node *>::const_iterator iter=candidates.begin();iter!=candidates.end();iter++)
    {
      const list<OutPort *>& mySet=(*pool.find(*iter)).second;
      if(mySet.size()==1)
        {
          if(alreadyFed==FREE_ST)
            {
              alreadyFed=FED_ST;//This the final choice. General case !
              if(!direction)
                info.pushInfoLink(*(mySet.begin()),end,I_BACK);
            }
          else if(alreadyFed==FED_ST)
              info.pushInfoLink(*(mySet.begin()),end,direction ? I_USELESS : I_BACK_USELESS);//Second or more turn in case of alreadyFed==FREE_ST before call of this method
        }
      else
        {
          if(dynamic_cast<ElementaryNode *>(*iter))
            {
              WarnReason reason;
              if(alreadyFed==FREE_ST)
                reason=direction ? W_COLLAPSE_EL : W_BACK_COLLAPSE_EL;
              else if(alreadyFed==FED_ST)
                reason=direction ? W_COLLAPSE_EL_AND_USELESS : W_BACK_COLLAPSE_EL_AND_USELESS;
              for(list<OutPort *>::const_iterator iter2=mySet.begin();iter2!=mySet.end();iter2++)    
                info.pushWarnLink(*iter2,end,reason);
            }
          else
            ((ComposedNode *)(*iter))->checkCFLinks(mySet,end,alreadyFed,direction,info);//Thanks to recursive model!
        }
    }
}

References checkCFLinks(), YACS::ENGINE::ComposedNode::FED_ST, YACS::ENGINE::ComposedNode::FREE_ST, YACS::ENGINE::I_BACK, YACS::ENGINE::I_BACK_USELESS, YACS::ENGINE::I_USELESS, YACS::ENGINE::LinkInfo::pushInfoLink(), YACS::ENGINE::LinkInfo::pushWarnLink(), YACS::ENGINE::W_BACK_COLLAPSE_EL, YACS::ENGINE::W_BACK_COLLAPSE_EL_AND_USELESS, YACS::ENGINE::W_COLLAPSE_EL, and YACS::ENGINE::W_COLLAPSE_EL_AND_USELESS.

Referenced by checkCFLinks().

◆ writeDot()

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

virtual

Dump to the input stream a dot representation of the node.

Parameters

os	: the input stream

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::Proc.

Definition at line 423 of file Bloc.cxx.

{
  os << "  subgraph cluster_" << getId() << "  {\n" ;
  list<Node *>nodes=getChildren();
  for(list<Node *>::const_iterator iter=nodes.begin();iter!=nodes.end();iter++)
    {
      (*iter)->writeDot(os);
      string p=(*iter)->getId();
      //not connected node
      if((*iter)->_inGate._backLinks.size() == 0) os << getId() << " -> " << p << ";\n";
      list<Node *>outnodes = (*iter)->getOutNodes();
      for(list<Node *>::const_iterator itout=outnodes.begin();itout!=outnodes.end();itout++)
        {
          os << p << " -> " << (*itout)->getId() << ";\n";
        }
    }
  os << "}\n" ;
  os << getId() << "[fillcolor=\"" ;
  YACS::StatesForNode state=getEffectiveState();
  os << getColorState(state);
  os << "\" label=\"" << "Bloc:" ;
  os << getQualifiedName() <<"\"];\n";
}

References getChildren(), YACS::ENGINE::Node::getColorState(), YACS::ENGINE::Node::getEffectiveState(), YACS::ENGINE::Node::getId(), YACS::ENGINE::Node::getOutNodes(), YACS::ENGINE::Node::getQualifiedName(), p, and yacsorb.CORBAEngineTest::state.

Referenced by YACS::ENGINE::Proc::writeDot().

Member Data Documentation

◆ _bwLinks

std::map<Node *,std::set<Node *> >* YACS::ENGINE::Bloc::_bwLinks

mutableprotected

For internal calculations.

Definition at line 42 of file Bloc.hxx.

Referenced by destructCFComputations(), performCFComputationsOnlyOneLevel(), and ~Bloc().

◆ _fwLinks

std::map<Node *,std::set<Node *> >* YACS::ENGINE::Bloc::_fwLinks

mutableprotected

For internal calculations.

Definition at line 40 of file Bloc.hxx.

Referenced by destructCFComputations(), performCFComputationsOnlyOneLevel(), and ~Bloc().

◆ _setOfNode

std::list<Node *> YACS::ENGINE::Bloc::_setOfNode

protected

Definition at line 38 of file Bloc.hxx.

Referenced by areAllSubNodesDone(), areAllSubNodesFinished(), Bloc(), edAddChild(), edRemoveChild(), exUpdateState(), getChildByShortName(), getNumberOfCFLinks(), getReadyTasks(), getSetOfInternalCFLinks(), init(), initComputation(), isNameAlreadyUsed(), performCFComputationsOnlyOneLevel(), splitIntoIndependantGraph(), and ~Bloc().

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

src/engine/Bloc.hxx
src/engine/Bloc.cxx
src/engine/Bloc_impl.cxx

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Bloc() [1/2]

◆ Bloc() [2/2]

◆ ~Bloc()

Member Function Documentation

◆ accept()

◆ analyzeParallelism()

◆ appendIfAlreadyFound()

◆ areAllSubNodesDone()

◆ areAllSubNodesFinished()

◆ areLinked()

◆ arePossiblyRunnableAtSameTime()

◆ checkCFLinks()

◆ checkControlDependancy()

◆ checkNoCyclePassingThrough()

◆ destructCFComputations()

◆ edAddChild()

◆ edGetDirectDescendants()

◆ edRemoveChild()

◆ exUpdateState()

◆ findAllNodesStartingFrom()

◆ findAllPathsStartingFrom()

◆ findUselessLinksIn()

◆ fitToPlayGround()

◆ getChildByShortName()

◆ getChildren()

◆ getMaxLevelOfParallelism()

◆ getNumberOfCFLinks()

◆ getReadyTasks()

◆ getSetOfInternalCFLinks()

◆ getWeightRegardingDPL()

◆ init()

◆ initComputation()

◆ isFinished()

◆ isNameAlreadyUsed()

◆ partitionRegardingDPL()

◆ performCFComputations()

◆ performCFComputationsOnlyOneLevel()

◆ propagePlayGround()

◆ removeRecursivelyRedundantCL()

◆ seekOkAndUseless1()

◆ seekUseless2()

◆ simpleClone()

◆ splitIntoIndependantGraph()

◆ typeName()

◆ updateStateOnFailedEventFrom()

◆ updateStateOnFinishedEventFrom()

◆ updateWithNewFind()

◆ verdictForCollapses()

◆ verdictForOkAndUseless1()

◆ writeDot()

Member Data Documentation

◆ _bwLinks

◆ _fwLinks

◆ _setOfNode