Base class for all composed nodes. More...

#include <ComposedNode.hxx>

Inheritance diagram for YACS::ENGINE::ComposedNode:

[legend]

Collaboration diagram for YACS::ENGINE::ComposedNode:

[legend]

Classes
struct	SortHierarc

Public Member Functions
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 ()

Static Public Member Functions
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	SEP_CHAR_BTW_LEVEL [] ="."

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

Protected Member Functions
	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 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)

Static Protected Attributes
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

Friends
class	Bloc

class	Loop

class	OutPort

class	ElementaryNode

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

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

Detailed Description

Base class for all composed nodes.

This is an abstract class that must be specialized.

Definition at line 42 of file ComposedNode.hxx.

Constructor & Destructor Documentation

◆ ComposedNode() [1/2]

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

protected

Definition at line 54 of file ComposedNode.cxx.

                                               :Node(name)
{
}

◆ ComposedNode() [2/2]

ComposedNode::ComposedNode	(	const ComposedNode &	other,
		ComposedNode *	father
	)

protected

Definition at line 58 of file ComposedNode.cxx.

                                                                         :Node(other,father)
{
}

◆ ~ComposedNode()

ComposedNode::~ComposedNode ( )

virtual

Definition at line 62 of file ComposedNode.cxx.

63{

64}

Member Function Documentation

◆ accept()

void ComposedNode::accept ( Visitor * visitor )

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoop, YACS::ENGINE::ForEachLoopDyn, YACS::ENGINE::ForLoop, YACS::ENGINE::Loop, YACS::ENGINE::OptimizerLoop, YACS::ENGINE::Proc, YACS::ENGINE::Switch, and YACS::ENGINE::WhileLoop.

Definition at line 1495 of file ComposedNode.cxx.

{
  list<Node *> constituents=edGetDirectDescendants();
  for(list<Node *>::iterator iter=constituents.begin(); iter!=constituents.end(); iter++)
    {
      (*iter)->accept(visitor);
    }
}

References edGetDirectDescendants().

Referenced by YACS::ENGINE::Executor::saveState(), and YACS::ENGINE::VisitorSaveSalomeSchemaUnsafe().

◆ buildDelegateOf() [1/2]

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

protectedvirtual

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::Loop, and YACS::ENGINE::OptimizerLoop.

Definition at line 1464 of file ComposedNode.cxx.

1465{

1466}

Referenced by edAddLink().

◆ buildDelegateOf() [2/2]

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

protectedvirtual

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::Loop, YACS::ENGINE::OptimizerLoop, and YACS::ENGINE::Switch.

Definition at line 1468 of file ComposedNode.cxx.

1469{

1470}

◆ checkBasicConsistency()

void ComposedNode::checkBasicConsistency ( ) const

virtual

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::Loop, and YACS::ENGINE::OptimizerLoop.

Definition at line 1603 of file ComposedNode.cxx.

{
  DEBTRACE("ComposedNode::checkBasicConsistency");
  std::list<InputPort *>::const_iterator iter;
  std::list<InputPort *> inports=getLocalInputPorts();
  for(iter=inports.begin();iter!=inports.end();iter++)
    (*iter)->checkBasicConsistency();
}

References DEBTRACE, and getLocalInputPorts().

Referenced by YACS::ENGINE::DynParaLoop::checkBasicConsistency(), YACS::ENGINE::Loop::checkBasicConsistency(), and edUpdateState().

◆ checkCFLinks()

void ComposedNode::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	:
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	: informations collectedduring the check

Reimplemented in YACS::ENGINE::Bloc, YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForLoop, YACS::ENGINE::Loop, YACS::ENGINE::OptimizerLoop, and YACS::ENGINE::Switch.

Definition at line 807 of file ComposedNode.cxx.

{
  static const char what[]="ComposedNode::checkCFLinks : Internal error occured - uncorrect hierarchy detected !";
  Node *nodeEnd=isInMyDescendance(end->getNode());
  if(!nodeEnd)
    return solveObviousOrDelegateCFLinks(starts,end,alreadyFed,direction,info);
  //This case is typically dedicated when direct son is ElementaryNode and self link is defined on this.
  if(!dynamic_cast<ElementaryNode *>(nodeEnd))
    throw Exception(what);
 
  list< OutPort *>::const_iterator iter=starts.begin();
  Node *nodeStart=(*iter)->getNode();
  iter++;
  if(nodeEnd!=nodeStart)
    throw Exception(what);
 
  for(;iter!=starts.end();iter++)
    if((*iter)->getNode()!=nodeStart)
      throw Exception(what);
  //Ok at this step we are sure that we have back links on the same elementary node.
  if(starts.size()>1)
    for(iter=starts.begin();iter!=starts.end();iter++)
      info.pushWarnLink(*iter,end,W_BACK_COLLAPSE_EL);
  else//here no need to look at 'alreadyFed' var because it is waranteed to be equal to FREE_ST by construction.
    info.pushInfoLink(*(starts.begin()),end,I_BACK);
  alreadyFed=FED_ST;
}

References FED_ST, YACS::ENGINE::Port::getNode(), YACS::ENGINE::I_BACK, isInMyDescendance(), YACS::ENGINE::LinkInfo::pushInfoLink(), YACS::ENGINE::LinkInfo::pushWarnLink(), solveObviousOrDelegateCFLinks(), and YACS::ENGINE::W_BACK_COLLAPSE_EL.

Referenced by YACS::ENGINE::Loop::checkCFLinks(), and YACS::ENGINE::Switch::checkCFLinks().

◆ checkConsistency()

void ComposedNode::checkConsistency ( LinkInfo & info ) const

Definition at line 615 of file ComposedNode.cxx.

{
  info.clearAll();
  info.setPointOfView((ComposedNode *)this);
  performCFComputations(info);
  list<InputPort *> setOfInToTest=getSetOfInputPort();
  for(list<InputPort *>::iterator iter1=setOfInToTest.begin();iter1!=setOfInToTest.end();iter1++)
    {
      vector<OutPort *> candidateForAdvCheck;
      set<OutPort *> outPorts=(*iter1)->edSetOutPort();
      //Filtering among outPorts, which of them, are candidates to fill *iter1 at the current scope.
      for(set<OutPort *>::iterator iter2=outPorts.begin();iter2!=outPorts.end();iter2++)
        {
          (*iter2)->checkConsistency(info);
          ComposedNode *manager=getLowestCommonAncestor((*iter2)->getNode(),(*iter1)->getNode());
          if(isInMyDescendance(manager))
            candidateForAdvCheck.push_back(*iter2);
        }
      if(!candidateForAdvCheck.empty())
        //End of filtering. Now regarding CF constraints for the current InPutPort.
        try
          {
            checkLinksCoherenceRegardingControl(candidateForAdvCheck,*iter1,info);
          }
        catch(YACS::Exception& ex)
          {
            std::string what=ex.what();
            what += "\nfor input port: ";
            what += (*iter1)->getNode()->getName();
            what += ".";
            what += (*iter1)->getName();
 
            destructCFComputations(info);
            throw YACS::Exception(what);
          }
      else
        //No backlinks
        if(!(*iter1)->canBeNull() && !(*iter1)->edIsManuallyInitialized())
          info.pushErrLink(0,*iter1,E_NEVER_SET_INPUTPORT);
    }
  destructCFComputations(info);
}

References checkLinksCoherenceRegardingControl(), YACS::ENGINE::LinkInfo::clearAll(), destructCFComputations(), YACS::ENGINE::E_NEVER_SET_INPUTPORT, testCppPluginInvokation::ex, getLowestCommonAncestor(), getSetOfInputPort(), isInMyDescendance(), performCFComputations(), YACS::ENGINE::LinkInfo::pushErrLink(), and YACS::ENGINE::LinkInfo::setPointOfView().

Referenced by main(), YACS::HMI::GenericGui::onRunLoadedSchema(), and YACS::HMI::EditionProc::synchronize().

◆ checkControlDependancy()

virtual void YACS::ENGINE::ComposedNode::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

protectedpure virtual

Implemented in YACS::ENGINE::Bloc, YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForLoop, YACS::ENGINE::Loop, YACS::ENGINE::OptimizerLoop, and YACS::ENGINE::StaticDefinedComposedNode.

Referenced by checkLinksCoherenceRegardingControl().

◆ checkDeploymentTree()

DeploymentTree ComposedNode::checkDeploymentTree ( bool deep ) const

Perform check of deployment consistency of the current graph.

Parameters

deep	if true a deep check is perfomed. Typically has to be called by an executor before any attempt to launch an execution.

Definition at line 189 of file ComposedNode.cxx.

{
  DeploymentTree ret;
  list< ElementaryNode * > tasks=getRecursiveConstituents();
  for(list< ElementaryNode * >::iterator iter=tasks.begin();iter!=tasks.end();iter++)
    {
      switch(ret.appendTask(*iter,(*iter)->getDynClonerIfExists(this)))
        {
        case DeploymentTree::DUP_TASK_NOT_COMPATIBLE_WITH_EXISTING_TREE:
          {
            string what("ComposedNode::checkDeploymentTree : ServiceNode with name \""); what+=(*iter)->getName();
            what+="\" coexists in a component with an another Task which context is incompatible with it.";
            throw Exception(what);
          }
        case DeploymentTree::DEPLOYABLE_BUT_NOT_SPECIFIED :
          {
            if(deep)
              {
                string what("ComposedNode::checkDeploymentTree : ServiceNode with name \""); what+=(*iter)->getName();
                what+="\" is deployable but no component is specified on it.";
                throw Exception(what);
              }
          }
        }
    }
  return ret;
}

References YACS::ENGINE::DeploymentTree::appendTask(), YACS::ENGINE::DeploymentTree::DEPLOYABLE_BUT_NOT_SPECIFIED, YACS::ENGINE::DeploymentTree::DUP_TASK_NOT_COMPATIBLE_WITH_EXISTING_TREE, and getRecursiveConstituents().

Referenced by YACS::ENGINE::ServiceNode::setComponent().

◆ checkInMyDescendance()

void ComposedNode::checkInMyDescendance ( Node * nodeToTest ) const

protected

Check if a node is in the descendance of this node.

Note: Check that 'nodeToTest' is in descendance of 'this' OR equal to 'this'

Exceptions

Exception : If 'nodeToTest' is NOT in descendance of 'this' AND not equal to 'this'

Parameters

nodeToTest : the node to check

Definition at line 1017 of file ComposedNode.cxx.

{
  const char whatC[]=" is not the descendance of node ";
  if(nodeToTest==0)
    {
      string what("node "); what+= nodeToTest->getName(); what+=" ";
      what+=whatC; what+=_name;
      throw Exception(what);
    }
  if((ComposedNode *)nodeToTest==this)
    return;
  ComposedNode *iter=nodeToTest->_father;
  while(iter!=0 && iter!=this)
    iter=iter->_father;
  if(iter==0)
    {
      string what("node "); what+= nodeToTest->getName(); what+=" ";
      what+=whatC; what+=_name;
      throw Exception(what);
    }
}

References YACS::ENGINE::Node::_father, YACS::ENGINE::Node::_name, and YACS::ENGINE::Node::getName().

Referenced by edAddLink(), edRemoveLink(), and getPortName().

◆ checkLinkPossibility()

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

protectedvirtual

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::OptimizerLoop, YACS::ENGINE::Switch, and YACS::ENGINE::WhileLoop.

Definition at line 1447 of file ComposedNode.cxx.

{
  if((dynamic_cast<DataFlowPort *>(start) || dynamic_cast<DataFlowPort *>(end))
     && (dynamic_cast<DataStreamPort *>(start) || dynamic_cast<DataStreamPort *>(end)))
    {//cross protocol required : deeper check needed
      bool isOK=false;
      list<ComposedNode *>::const_iterator iter;
      for(iter=pointsOfViewStart.begin();iter!=pointsOfViewStart.end() && !isOK;iter++)
        isOK=(*iter)->isRepeatedUnpredictablySeveralTimes();
      for(iter=pointsOfViewEnd.begin();iter!=pointsOfViewEnd.end() && !isOK;iter++)
        isOK=(*iter)->isRepeatedUnpredictablySeveralTimes();
      if(!isOK)
        throw Exception("ComposedNode::checkLinkPossibility : Request for cross protocol link impossible.");
    }
}

Referenced by YACS::ENGINE::DynParaLoop::checkLinkPossibility(), and edAddLink().

◆ checkLinksCoherenceRegardingControl()

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

protected

call it only for 'starts' to 'end' links DEALED by 'this'.

Definition at line 717 of file ComposedNode.cxx.

{
  map < ComposedNode *, list<OutPort *>, SortHierarc > outputs;//forward link classical
  vector<OutPort *> outputsCross;//forward link cross
  map < ComposedNode *, list<OutPort *>, SortHierarc > outputsBw;//backward
  vector<OutPort *>::const_iterator iter1;
  //vector<DataPort *> history=((*iter1).second)[0]->calculateHistoryOfLinkWith(end);
  //DataPort *cross=DataPort::isCrossingType(history);
  for(iter1=starts.begin();iter1!=starts.end();iter1++)
    {
      ComposedNode *manager=getLowestCommonAncestor((*iter1)->getNode(),end->getNode());
      manager->checkControlDependancy((*iter1), end, false, outputs, outputsCross, outputsBw, info);
    }
  //Ok now let's regarding outputs all combinations : (outputs.size())*(outputs.size()-1)/2
  unsigned char isAlreadyFed=FREE_ST;
  //Dealing excusively with DS. Level is useless here because simultaneity is required for DS.
  if(outputsCross.size()>0)
    {
      isAlreadyFed=FED_DS_ST;
      if(outputsCross.size()>1)
        for(vector< OutPort *>::const_iterator iter1=outputsCross.begin();iter1!=(outputsCross.end()-2);iter1++)
          info.pushErrLink(*iter1,end,E_COLLAPSE_DS);
    }
  map < ComposedNode *, list<OutPort *>, SortHierarc >::iterator iter3=outputs.begin();
  for(;iter3!=outputs.end();iter3++)
    ((*iter3).first)->checkCFLinks((*iter3).second,end,isAlreadyFed,true,info);
  if(isAlreadyFed==FREE_ST)
    if(!end->edIsManuallyInitialized())
      info.pushErrLink(0,end,E_ONLY_BACKWARD_DEFINED);
  isAlreadyFed=FREE_ST;
  //
  map < ComposedNode *, list<OutPort *>, SortHierarc >::reverse_iterator iter5=outputsBw.rbegin();
  for(;iter5!=outputsBw.rend();iter5++)
    ((*iter5).first)->checkCFLinks((*iter5).second,end,isAlreadyFed,false,info);
}

References checkControlDependancy(), YACS::ENGINE::E_COLLAPSE_DS, YACS::ENGINE::E_ONLY_BACKWARD_DEFINED, YACS::ENGINE::InputPort::edIsManuallyInitialized(), FED_DS_ST, FREE_ST, getLowestCommonAncestor(), YACS::ENGINE::Port::getNode(), and YACS::ENGINE::LinkInfo::pushErrLink().

Referenced by checkConsistency().

◆ checkNoCrossHierachyWith()

void ComposedNode::checkNoCrossHierachyWith ( Node * node ) const

protected

This method check that G1 <- G2 <- G3 <- G1 does not happened. Typically called by methods that set a hierarchy (Bloc::edAddChild, Loop::edSetNode, ...).

Definition at line 662 of file ComposedNode.cxx.

{
  ComposedNode *nodeC=dynamic_cast<ComposedNode *>(node);
  if(!nodeC)
    return ;
  list<ComposedNode *> ascendants=getAllAscendanceOf();
  if(find(ascendants.begin(),ascendants.end(),nodeC)!=ascendants.end())
    {
      const char what[]="ComposedNode::checkNoCrossHierachyWith : ComposedNode with name \"";
      string stream(what); stream+=node->getName(); stream+="\" is already in hierarchy ascendance of node with name \"";
      stream+=_name; stream+="\" ; So it can't be now in its descendance !";
      throw Exception(stream);
    }
}

References YACS::ENGINE::Node::_name, YACS::ENGINE::Node::getAllAscendanceOf(), and YACS::ENGINE::Node::getName().

Referenced by YACS::ENGINE::DynParaLoop::checkConsistencyAndSetNode(), YACS::ENGINE::Bloc::edAddChild(), YACS::ENGINE::Switch::edSetNode(), and YACS::ENGINE::Loop::edSetNode().

◆ checkNoCyclePassingThrough()

virtual void YACS::ENGINE::ComposedNode::checkNoCyclePassingThrough ( Node * node )

protectedpure virtual

Implemented in YACS::ENGINE::Bloc, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::Loop, YACS::ENGINE::OptimizerLoop, and YACS::ENGINE::Switch.

Referenced by edAddLink().

◆ cleanNodes()

void ComposedNode::cleanNodes ( )

virtual

Clean the composed node in case of not clean exit.

This method should be called on a control-c or sigterm

Reimplemented from YACS::ENGINE::Node.

Definition at line 1629 of file ComposedNode.cxx.

{
  DEBTRACE("ComposedNode::cleanNodes");
  list<Node *> nodes=edGetDirectDescendants();
  for(list<Node *>::iterator iter=nodes.begin();iter!=nodes.end();iter++)
    (*iter)->cleanNodes();
}

References DEBTRACE, and edGetDirectDescendants().

Referenced by Handler().

◆ connected()

void ComposedNode::connected ( )

Definition at line 1491 of file ComposedNode.cxx.

1492{

1493}

◆ destructCFComputations()

void ComposedNode::destructCFComputations ( LinkInfo & info ) const

protectedvirtual

destroy recursively all results of initial computations.

Reimplemented in YACS::ENGINE::Bloc.

Definition at line 687 of file ComposedNode.cxx.

{
  list<Node *> nodes=edGetDirectDescendants();
  for(list<Node *>::iterator iter=nodes.begin();iter!=nodes.end();iter++)
    if(dynamic_cast<ComposedNode *>(*iter))
      ((ComposedNode *)(*iter))->destructCFComputations(info);
}

References destructCFComputations(), and edGetDirectDescendants().

Referenced by checkConsistency(), YACS::ENGINE::Bloc::destructCFComputations(), and destructCFComputations().

◆ edAddCFLink()

bool ComposedNode::edAddCFLink	(	Node *	nodeS,
		Node *	nodeE
	)

Add a controlflow link between two nodes.

Add a controlflow link between two nodes by calling edAddLink on their control ports

Definition at line 421 of file ComposedNode.cxx.

{
  return edAddLink(nodeS->getOutGate(),nodeE->getInGate());
}

References edAddLink(), YACS::ENGINE::Node::getInGate(), and YACS::ENGINE::Node::getOutGate().

Referenced by YACS::ENGINE::Bloc::Bloc(), edAddDFLink(), YACS::HMI::CommandAddControlLink::localExecute(), and YACS::HMI::SubjectNode::restoreLinks().

◆ edAddChild()

bool ComposedNode::edAddChild ( Node * DISOWNnode )

virtual

Reimplemented in YACS::ENGINE::Bloc, YACS::ENGINE::DynParaLoop, YACS::ENGINE::Loop, and YACS::ENGINE::Switch.

Definition at line 531 of file ComposedNode.cxx.

{
  return false; // --- reimplemented in derived classes
}

Referenced by YACS::HMI::CommandReparentNode::localExecute(), YACS::HMI::CommandPutInComposedNode::localExecute(), YACS::HMI::CommandCopyNode::localExecute(), YACS::HMI::CommandReparentNode::localReverse(), YACS::HMI::CommandPutInComposedNode::localReverse(), and YACS::HMI::SubjectNode::registerUndoDestroy().

◆ edAddDFLink()

bool ComposedNode::edAddDFLink	(	OutPort *	start,
		InPort *	end
	)

virtual

Connect an OutPort to an InPort and add the necessary control link.

Connect the ports with a data link (edAddLink) and add a control flow link between the children of the lowest common ancestor node.

Parameters

start	: the OutPort to connect
end	: the InPort to connect

Returns: true if a new link has been created, false otherwise.

Reimplemented in YACS::ENGINE::DynParaLoop, and YACS::ENGINE::Loop.

Definition at line 333 of file ComposedNode.cxx.

{
  Node* n1=start->getNode();
  Node* n2=end->getNode();
  DEBTRACE( n1->getName() << ":" << n2->getName())
  ComposedNode* father=getLowestCommonAncestor(n1,n2);
  DEBTRACE( "ComposedNode::edAddDFLink: this="<<this->getName() 
            << " father=" << father->getName() )
  DEBTRACE( "ComposedNode::edAddDFLink: OutPort=" << start->getName()
            << " InPort=" << end->getName() )
  if (father != this)
    {
      bool ret = father->edAddDFLink(start,end); // special treatement for loop
      return ret;
    }
  if(n2 == father)
    throw Exception("Back link authorized only in special context (loop for example)");
 
  bool ret= edAddLink(start,end);
  if(n1 != father)
    {
      //add a control link only if nodes are not in the same descendance
      //if n1 == father (n2 is after n1) : the control link is not needed 
      //if n2 == father (n1 is after n2) : it's a back link authorized only in loop context
      while(n1->getFather() != father)
        n1=n1->getFather();
      while(n2->getFather() != father)
        n2=n2->getFather();
      try
        {
          edAddCFLink(n1,n2);
        }
      catch (Exception& ex)
        {
          // --- remove DF link already created in case of cycle dtection
          DEBTRACE("Cycle detected, remove CF link");
          if(start->isAlreadyLinkedWith(end))
            edRemoveLink(start, end);
          throw ex;          
        }
    }
  return ret;
}

References DEBTRACE, edAddCFLink(), edAddDFLink(), edAddLink(), edRemoveLink(), testCppPluginInvokation::ex, YACS::ENGINE::Node::getFather(), getLowestCommonAncestor(), getName(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Port::getNode(), and YACS::ENGINE::OutPort::isAlreadyLinkedWith().

Referenced by edAddDFLink(), YACS::ENGINE::ElementaryNode::getReadyTasks(), YACS::HMI::CommandAddLink::localExecute(), and YACS::HMI::SubjectNode::restoreLinks().

◆ edAddLink() [1/2]

bool ComposedNode::edAddLink	(	OutGate *	start,
		InGate *	end
	)

Add a controlflow link between two control ports.

Note: Precondition : 'start' AND 'end' are in/outGate contained in a node in DIRECT descendance of 'this'.

Exceptions

Exception : If a cycle has been detected, or incompatibility between input and output, or 'start'/'end' is/are NOT in/outputPort contained in a node in descendance of 'this', or a mutilple link to an input not supporting it.

Returns: true if a new link has been created, false otherwise.

Definition at line 387 of file ComposedNode.cxx.

{
  Node* n1=start->getNode();
  Node* n2=end->getNode();
  if(n1==n2)
    throw Exception("ComposedNode::edAddLink: can not add a control link to a node with itself",1);
  ComposedNode* father=checkHavingCommonFather(start->getNode(),end->getNode());
  if(father==0)
    throw Exception("ComposedNode::edAddLink: Trying to add CF link on orphan nodes.");
  if(father!=this)
    {
      checkInMyDescendance(father);
      return father->edAddLink(start,end);
    }
  bool ret=start->edAddInGate(end);
  if(ret)
    try
      {
        checkNoCyclePassingThrough(end->getNode());
      }
    catch (Exception& ex)
      {
        // --- remove  created CF link in case of cycle detection
        DEBTRACE("Cycle detected, remove CF link");
        edRemoveCFLink(start->getNode(), end->getNode());
        throw ex;
      }
  return ret;
}

References YACS::ENGINE::Node::checkHavingCommonFather(), checkInMyDescendance(), checkNoCyclePassingThrough(), DEBTRACE, YACS::ENGINE::OutGate::edAddInGate(), edAddLink(), edRemoveCFLink(), testCppPluginInvokation::ex, and YACS::ENGINE::Port::getNode().

◆ edAddLink() [2/2]

bool ComposedNode::edAddLink	(	OutPort *	start,
		InPort *	end
	)

Add a dataflow link between two data ports.

Precondition : 'start' AND 'end' are in/outputPort contained in a node in descendance of 'this'.

Exceptions

Exception : if incompatibility between input and output (type), or 'start'/'end' is/are NOT in/outputPort contained in a node in descendance of 'this', or a multiple link to an input not supporting it.

Returns: true if a new link has been created, false otherwise.

Definition at line 273 of file ComposedNode.cxx.

{
  DEBTRACE("ComposedNode::edAddLink");
  set<OutPort *> represented;
 
  start->getAllRepresented(represented);
  if(represented.size()!=1)
    {
      bool ret=false;
      for(set<OutPort *>::iterator iter=represented.begin();iter!=represented.end();iter++)
        ret|=edAddLink(*iter,end);
      return ret;
    }
  if(start->isAlreadyLinkedWith(end))
    return false;
  ComposedNode* lwstCmnAnctr=getLowestCommonAncestor(start->getNode(),end->getNode());
  list<ComposedNode *> allAscendanceOfNodeStart=start->getNode()->getAllAscendanceOf(lwstCmnAnctr);
  list<ComposedNode *> allAscendanceOfNodeEnd=end->getNode()->getAllAscendanceOf(lwstCmnAnctr);
  checkInMyDescendance(lwstCmnAnctr);
  lwstCmnAnctr->checkLinkPossibility(start,allAscendanceOfNodeStart,end,allAscendanceOfNodeEnd);
  ComposedNode *iterS;
  if(dynamic_cast<ComposedNode *>(start->getNode()))
    iterS=(ComposedNode *)start->getNode();
  else
    iterS=start->getNode()->_father;
  pair<OutPort *, OutPort *> pO(start,start);
  while(iterS!=lwstCmnAnctr)
    {
      iterS->buildDelegateOf(pO, end, allAscendanceOfNodeEnd);
      iterS=iterS->_father;
    }
  if(dynamic_cast<ComposedNode *>(end->getNode()))
    iterS=(ComposedNode *)end->getNode();
  else
    iterS=end->getNode()->_father;
 
  InPort *currentPortI=end;
  bool isLoopProofLink(true),isFirstTurn(true);
  while(iterS!=lwstCmnAnctr)
    {
      if(!isFirstTurn && iterS->isLoop())// isFirstTurn is a way to filter special inputs like nbBranches, splitPort... These special inputs are loopProof -> they must not be realeased by ForEachLoop::exUpdateState
        isLoopProofLink=false;
      iterS->buildDelegateOf(currentPortI, start, allAscendanceOfNodeStart);
      iterS=iterS->_father;
      isFirstTurn=false;
    }
  bool ret=(pO.first)->addInPort(currentPortI);
  end->edNotifyReferencedBy(pO.second,isLoopProofLink);
  return ret;
}

References YACS::ENGINE::Node::_father, buildDelegateOf(), checkInMyDescendance(), checkLinkPossibility(), DEBTRACE, edAddLink(), YACS::ENGINE::InPort::edNotifyReferencedBy(), YACS::ENGINE::Node::getAllAscendanceOf(), YACS::ENGINE::OutPort::getAllRepresented(), getLowestCommonAncestor(), YACS::ENGINE::Port::getNode(), YACS::ENGINE::OutPort::isAlreadyLinkedWith(), and isLoop().

Referenced by YACS::ENGINE::Bloc::Bloc(), YACS::ENGINE::Loop::buildDelegateOf(), YACS::ENGINE::DynParaLoop::cloneAndPlaceNodesCoherently(), YACS::ENGINE::DynParaLoop::DynParaLoop(), edAddCFLink(), edAddDFLink(), YACS::ENGINE::DynParaLoop::edAddDFLink(), YACS::ENGINE::Loop::edAddDFLink(), edAddLink(), YACS::ENGINE::ForLoop::ForLoop(), YACS::ENGINE::ElementaryNode::getReadyTasks(), YACS::HMI::CommandAddLink::localExecute(), YACS::ENGINE::OptimizerLoop::OptimizerLoop(), YACS::HMI::SubjectNode::restoreLinks(), and YACS::ENGINE::WhileLoop::WhileLoop().

◆ edDisconnectAllLinksWithMe()

void ComposedNode::edDisconnectAllLinksWithMe ( )

protectedvirtual

Called typically by ComposedNode to correctly update DF/CF/DS links

Reimplemented from YACS::ENGINE::Node.

Definition at line 903 of file ComposedNode.cxx.

{
  //CF
  DEBTRACE("-");
  Node::edDisconnectAllLinksWithMe();
  //Leaving part
  DEBTRACE("--");
  vector< pair<OutPort *, InPort *> > linksToDestroy=getSetOfLinksLeavingCurrentScope();
  vector< pair<OutPort *, InPort *> >::iterator iter;
  for(iter=linksToDestroy.begin();iter!=linksToDestroy.end();iter++)
    {
      DEBTRACE("---");
      (*iter).first->removeInPort((*iter).second,true);
    }
  //Arriving part
  vector< pair<InPort *, OutPort *> > linksToDestroy2=getSetOfLinksComingInCurrentScope();
  vector< pair<InPort *, OutPort *> >::iterator iter2;
  for(iter2=linksToDestroy2.begin();iter2!=linksToDestroy2.end();iter2++)
    {
      DEBTRACE("----");
      (*iter2).second->removeInPort((*iter2).first,true);
    }
}

References DEBTRACE, YACS::ENGINE::Node::edDisconnectAllLinksWithMe(), getSetOfLinksComingInCurrentScope(), and getSetOfLinksLeavingCurrentScope().

◆ edGetDirectDescendants()

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

pure virtual

Implemented in YACS::ENGINE::Bloc, YACS::ENGINE::DynParaLoop, YACS::ENGINE::Loop, and YACS::ENGINE::Switch.

Referenced by YACS::HMI::GuiEditor::_createNode(), accept(), YACS::HMI::SceneBlocItem::arrangeCanvasNodes(), YACS::HMI::SceneComposedNodeItem::arrangeNodes(), cleanNodes(), destructCFComputations(), edUpdateState(), YACS::ENGINE::VisitorSaveSchema::getAllNodes(), getAllRecursiveConstituents(), getAllRecursiveNodes(), YACS::HMI::SchemaComposedNodeItem::getDirectDescendants(), getErrorReport(), YACS::HMI::SceneBlocItem::getNodesInfo(), getNumberOfInputPorts(), getNumberOfOutputPorts(), getProgressWeight(), getRecursiveConstituents(), getSetOfInputDataStreamPort(), getSetOfInputPort(), getSetOfOutputDataStreamPort(), getSetOfOutputPort(), YACS::HMI::SubjectComposedNode::loadChildren(), YACS::HMI::SubjectComposedNode::loadLinks(), performCFComputations(), YACS::HMI::GuiEditor::PutSubjectInBloc(), removeRecursivelyRedundantCL(), resetState(), shutdown(), YACS::ENGINE::VisitorSaveSchema::writeControls(), YACS::ENGINE::VisitorSaveSchema::writeSimpleDataLinks(), and YACS::ENGINE::VisitorSaveSchema::writeSimpleStreamLinks().

◆ edRemoveCFLink()

void ComposedNode::edRemoveCFLink	(	Node *	nodeS,
		Node *	nodeE
	)

Remove a controlflow link.

Definition at line 427 of file ComposedNode.cxx.

{
  edRemoveLink(nodeS->getOutGate(),nodeE->getInGate());
}

References edRemoveLink(), YACS::ENGINE::Node::getInGate(), and YACS::ENGINE::Node::getOutGate().

Referenced by edAddLink(), YACS::ENGINE::Bloc::removeRecursivelyRedundantCL(), and YACS::HMI::SubjectControlLink::~SubjectControlLink().

◆ edRemoveChild()

void ComposedNode::edRemoveChild ( Node * node )

virtual

Remove a child node.

Reimplemented in YACS::ENGINE::Bloc, YACS::ENGINE::DynParaLoop, YACS::ENGINE::Loop, and YACS::ENGINE::Switch.

Definition at line 537 of file ComposedNode.cxx.

{
  if(!node)
    return;
  if (node->_father!=this)
    {
      string what("node "); what+= node->getName() ; what+=" is not a child of node "; what += getName();
      throw Exception(what);
    }
  node->edDisconnectAllLinksWithMe();
  node->_father = 0;
  //set _modified flag so edUpdateState() can refresh state
  modified();
}

References YACS::ENGINE::Node::_father, YACS::ENGINE::Node::edDisconnectAllLinksWithMe(), getName(), YACS::ENGINE::Node::getName(), and YACS::ENGINE::Node::modified().

Referenced by YACS::ENGINE::DynParaLoop::checkConsistencyAndSetNode(), YACS::ENGINE::Switch::edReleaseCase(), YACS::ENGINE::Bloc::edRemoveChild(), YACS::ENGINE::DynParaLoop::edRemoveChild(), YACS::ENGINE::Loop::edRemoveChild(), YACS::ENGINE::Loop::edRemoveNode(), YACS::ENGINE::Loop::edSetNode(), YACS::HMI::CommandReparentNode::localExecute(), YACS::HMI::CommandPutInComposedNode::localExecute(), YACS::HMI::CommandReparentNode::localReverse(), YACS::HMI::CommandPutInComposedNode::localReverse(), YACS::ENGINE::DynParaLoop::removeNode(), and YACS::HMI::SubjectNode::~SubjectNode().

◆ edRemoveLink() [1/2]

void ComposedNode::edRemoveLink	(	OutGate *	start,
		InGate *	end
	)

Remove a controlflow link.

Definition at line 523 of file ComposedNode.cxx.

{
  ComposedNode* father=checkHavingCommonFather(start->getNode(),end->getNode());
  if(father!=this)
    throw Exception("edRemoveLink : nodes not in direct descendance of this");
  start->edRemoveInGate(end);
}

References YACS::ENGINE::Node::checkHavingCommonFather(), YACS::ENGINE::OutGate::edRemoveInGate(), and YACS::ENGINE::Port::getNode().

◆ edRemoveLink() [2/2]

void ComposedNode::edRemoveLink	(	OutPort *	start,
		InPort *	end
	)

Remove a dataflow link.

Precondition : 'start' AND 'end' are in/outputPort contained in a node in descendance of 'this'.

Exceptions

Exception : If the specified link does not exist. The content of Exception is different in accordance with the link from 'start' to 'end' implies DF/DS gateway.

Definition at line 441 of file ComposedNode.cxx.

{
  if(!start->isAlreadyLinkedWith(end))
    throw Exception("ComposedNode::edRemoveLink : unexisting link");
  ComposedNode* lwstCmnAnctr=getLowestCommonAncestor(start->getNode(),end->getNode());
  checkInMyDescendance(lwstCmnAnctr);
  list<ComposedNode *> allAscendanceOfNodeStart=start->getNode()->getAllAscendanceOf(lwstCmnAnctr);
  list<ComposedNode *> allAscendanceOfNodeEnd=end->getNode()->getAllAscendanceOf(lwstCmnAnctr);
 
  // --- Part of test if the link from 'start' to 'end' really exist particulary all eventually intermediate ports created
 
  ComposedNode *iterS=start->getNode()->_father;
  pair<OutPort *,OutPort *> currentPortO(start,start);
  vector<pair< ComposedNode * , pair < OutPort* , OutPort *> > > needsToDestroyO;
 
  Node *nodeOTemp=start->getNode();
  if(*nodeOTemp<*lwstCmnAnctr)
    {
      iterS=nodeOTemp->_father;
      while(iterS!=lwstCmnAnctr)
        {
          if (!iterS)
            {
              stringstream what;
              what << "ComposedNode::edRemoveLink: "
                   << start->getNode()->getName() << "." <<start->getName() << "->"
                   << end->getNode()->getName() << "." << end->getName();
              throw Exception(what.str());
            }
          OutPort *tmp=currentPortO.first;
          iterS->getDelegateOf(currentPortO, end, allAscendanceOfNodeEnd);
          needsToDestroyO.push_back(pair< ComposedNode * , pair < OutPort* , OutPort *> >(iterS,pair<OutPort* , OutPort *> (tmp,currentPortO.first)));
          iterS=iterS->_father;
        }
    }
  Node *nodeTemp=end->getNode();
  InPort * currentPortI=end;
  if(*nodeTemp<*lwstCmnAnctr)
    {
      iterS=nodeTemp->_father;    
      while(iterS!=lwstCmnAnctr)
        {
          if (!iterS)
            {
              stringstream what;
              what << "ComposedNode::edRemoveLink: "
                   << start->getNode()->getName() << "." <<start->getName() << "->"
                   << end->getNode()->getName() << "." << end->getName();
              throw Exception(what.str());
            }
          iterS->getDelegateOf(currentPortI, start, allAscendanceOfNodeStart);
          iterS=iterS->_father;
        }
    }
  // --- End of test for evt intermediate ports created
  
  (currentPortO.first)->removeInPort(currentPortI,false);
  set<OutPort *> repr;
  (currentPortO.second)->getAllRepresented(repr);
  if(repr.size()==1)
    end->edNotifyDereferencedBy(currentPortO.second);
 
  // --- Performing deletion of intermediate ports
  
  iterS=start->getNode()->_father;
  vector<pair< ComposedNode * , pair < OutPort* , OutPort *> > >::reverse_iterator iter;
  for(iter=needsToDestroyO.rbegin();iter!=needsToDestroyO.rend();iter++)
    (*iter).first->releaseDelegateOf(((*iter).second).first, ((*iter).second).second, end,allAscendanceOfNodeEnd);
  nodeTemp=end->getNode();
  if(*nodeTemp<*lwstCmnAnctr)
    {
      iterS=end->getNode()->_father;
      currentPortI=end;
      while(iterS!=lwstCmnAnctr)
        {
          iterS->releaseDelegateOf(currentPortI, start, allAscendanceOfNodeStart);
          iterS=iterS->_father;
        }
    }
}

References YACS::ENGINE::Node::_father, checkInMyDescendance(), YACS::ENGINE::InPort::edNotifyDereferencedBy(), YACS::ENGINE::Node::getAllAscendanceOf(), getDelegateOf(), getLowestCommonAncestor(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Port::getNode(), YACS::ENGINE::OutPort::isAlreadyLinkedWith(), and releaseDelegateOf().

Referenced by edAddDFLink(), YACS::ENGINE::InPort::edRemoveAllLinksLinkedWithMe(), edRemoveCFLink(), YACS::ENGINE::OutputDataStreamPort::edRemoveInputDataStreamPort(), YACS::ENGINE::OutputPort::edRemoveInputPort(), and YACS::HMI::SubjectLink::localclean().

◆ edUpdateState()

void ComposedNode::edUpdateState ( )

virtual

update the status of the node

Only useful when editing a schema Do nothing in base Node : to implement in derived classes

Reimplemented from YACS::ENGINE::Node.

Definition at line 1532 of file ComposedNode.cxx.

{
  DEBTRACE("ComposedNode::edUpdateState(): " << _state << " " << _modified);
  YACS::StatesForNode state=YACS::READY;
 
  try
    {
      checkBasicConsistency();
      _errorDetails="";
    }
  catch(Exception& e)
    {
      state=YACS::INVALID;
      _errorDetails=e.what();
    }
  DEBTRACE("ComposedNode::edUpdateState: " << _errorDetails);
 
  //update children if needed
  list<Node *> constituents=edGetDirectDescendants();
  for(list<Node *>::iterator iter=constituents.begin(); iter!=constituents.end(); iter++)
    {
      if(!(*iter)->isValid())
        state=YACS::INVALID;
    }
  if(state != _state)
    setState(state);
  _modified=0;
}

References YACS::ENGINE::Node::_errorDetails, YACS::ENGINE::Node::_modified, YACS::ENGINE::Node::_state, checkBasicConsistency(), DEBTRACE, edGetDirectDescendants(), YACS::INVALID, YACS::READY, YACS::ENGINE::Node::setState(), yacsorb.CORBAEngineTest::state, and YACS::Exception::what().

Referenced by YACS::ENGINE::Proc::modified(), and YACS::ENGINE::Proc::setEdition().

◆ getAllInPortsComingFromOutsideOfCurrentScope()

std::set< InPort * > ComposedNode::getAllInPortsComingFromOutsideOfCurrentScope ( ) const

virtual

List all input ports that are linked to out of scope ports.

List all input ports of 'this' so that, for each it exists at least 1 link coming from outside to it.

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::Switch.

Definition at line 885 of file ComposedNode.cxx.

{
  set<InPort *> ret;
  list<InPort *> temp=getSetOfInPort();
  for(list<InPort *>::iterator iter2=temp.begin();iter2!=temp.end();iter2++)
    {
      set<OutPort *> temp2=(*iter2)->edSetOutPort();
      for(set<OutPort *>::iterator iter3=temp2.begin();iter3!=temp2.end();iter3++)
        if(*iter3)
          if(!isInMyDescendance((*iter3)->getNode()))
            {
              ret.insert(*iter2);
              break;
            }
    }
  return ret;
}

References YACS::ENGINE::Node::getSetOfInPort(), and isInMyDescendance().

Referenced by YACS::ENGINE::ForEachLoopGen::exUpdateState(), YACS::ENGINE::Switch::getAllInPortsComingFromOutsideOfCurrentScope(), getSetOfLinksComingInCurrentScope(), and YACS::ENGINE::DynParaLoop::prepareInputsFromOutOfScope().

◆ getAllOutPortsLeavingCurrentScope()

std::set< OutPort * > ComposedNode::getAllOutPortsLeavingCurrentScope ( ) const

virtual

List all output ports of children nodes that are linked to out of scope input ports.

Note: List all output ports of nodes sons of 'this' that are linked to input ports of nodes not in descendance of 'this'. This method contrary to getAllInPortsComingFromOutsideOfCurrentScope is NOT virtual because for the moment all daughter classes have no more hidden YACS::ENGINE::OutPort.

Implements YACS::ENGINE::Node.

Definition at line 861 of file ComposedNode.cxx.

{
  set<OutPort *> ret;
  list<OutPort *> temp=getSetOfOutPort();
  for(list<OutPort *>::iterator iter2=temp.begin();iter2!=temp.end();iter2++)
    {
      set<InPort *> temp2=(*iter2)->edSetInPort();
      for(set<InPort *>::iterator iter3=temp2.begin();iter3!=temp2.end();iter3++)
        if(!isInMyDescendance((*iter3)->getNode()))
          {
            ret.insert(*iter2);
            break;
          }
    }
  return ret;
}

References YACS::ENGINE::Node::getSetOfOutPort(), and isInMyDescendance().

Referenced by YACS::ENGINE::ForEachLoopGen::exUpdateState(), YACS::ENGINE::ForLoop::exUpdateState(), YACS::ENGINE::OptimizerLoop::exUpdateState(), YACS::ENGINE::Switch::exUpdateState(), YACS::ENGINE::WhileLoop::exUpdateState(), getSetOfLinksLeavingCurrentScope(), and YACS::ENGINE::OptimizerLoop::initInterceptors().

◆ getAllRecursiveConstituents()

list< Node * > ComposedNode::getAllRecursiveConstituents ( )

virtual

Idem getAllRecursiveNodes, but this node is NOT included.

Definition at line 1134 of file ComposedNode.cxx.

{
  list<Node *> ret;
  list<Node *> setOfNode=edGetDirectDescendants();
  for(list<Node *>::const_iterator iter=setOfNode.begin();iter!=setOfNode.end();iter++)
    {
      if ( dynamic_cast<ComposedNode*> (*iter) )
        {
          list<Node *> myCurrentSet=((ComposedNode*)(*iter))->getAllRecursiveConstituents();
          ret.insert(ret.end(),myCurrentSet.begin(),myCurrentSet.end());
          ret.push_back(*iter);
        }
      else
        {
          list<ElementaryNode *> myCurrentSet=(*iter)->getRecursiveConstituents();
          ret.insert(ret.end(),myCurrentSet.begin(),myCurrentSet.end());
        }
    }
  return ret;
}

References edGetDirectDescendants(), and getAllRecursiveConstituents().

Referenced by YACS::ENGINE::OptimizerLoop::finalize(), YACS::ENGINE::DynParaLoop::forwardExecStateToOriginalBody(), getAllRecursiveConstituents(), YACS::ENGINE::Proc::getIds(), YACS::ENGINE::Proc::getNumIds(), YACS::HMI::GuiExecutor::registerStatusObservers(), YACS::HMI::GuiExecutor::updateSchema(), and YACS::ENGINE::ForEachLoopGen::updateStateForWorkNodeOnFinishedEventFrom().

◆ getAllRecursiveNodes()

list< Node * > ComposedNode::getAllRecursiveNodes ( )

Get all children nodes elementary and composed including this node.

Definition at line 1156 of file ComposedNode.cxx.

{
  list<Node *> ret;
  list<Node *> setOfNode=edGetDirectDescendants();
  for(list<Node *>::iterator iter=setOfNode.begin();iter!=setOfNode.end();iter++)
    {
      if ( dynamic_cast<ElementaryNode*> (*iter) )
        {
          list<ElementaryNode *> myCurrentSet=(*iter)->getRecursiveConstituents();
          ret.insert(ret.end(),myCurrentSet.begin(),myCurrentSet.end());
        }
      else
        {
          list<Node *> myCurrentSet=((ComposedNode*)(*iter))->getAllRecursiveNodes();
          ret.insert(ret.end(),myCurrentSet.begin(),myCurrentSet.end());
        }
    }
  ret.push_back(this);
  return ret;
}

References edGetDirectDescendants(), and getAllRecursiveNodes().

Referenced by getAllRecursiveNodes(), Proc_i::getIds(), main(), and YACS::HMI::SubjectNode::registerUndoDestroy().

◆ getChildByName()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 999 of file ComposedNode.cxx.

{
  string potentiallyDirectSonName, remainsPath;
  bool forwardNeeded=ComposedNode::splitNamesBySep(name, SEP_CHAR_BTW_LEVEL,
                                                   potentiallyDirectSonName,remainsPath,false);
  Node *child=getChildByShortName(potentiallyDirectSonName);
  if(!forwardNeeded)
    return child;
  else
    return child->getChildByName(remainsPath);
}

References YACS::ENGINE::Node::getChildByName(), getChildByShortName(), SEP_CHAR_BTW_LEVEL, and splitNamesBySep().

◆ getChildByShortName()

virtual Node * YACS::ENGINE::ComposedNode::getChildByShortName ( const std::string & name ) const

protectedpure virtual

Implemented in YACS::ENGINE::Bloc, YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::Loop, and YACS::ENGINE::Switch.

Referenced by getChildByName(), getOutPort(), and getOutputPort().

◆ getChildName()

string ComposedNode::getChildName ( const Node * node ) const

Definition at line 968 of file ComposedNode.cxx.

{
  string nodeName=node->getQualifiedName();    
  if (!isNodeAlreadyAggregated(node))
    {
      if (node->getName() == "thisIsAFakeNode")
        {
          string child = node->getName()+".thisIsAFakeNode";
          return child;
        }
      else
        {
          string what("node "); what+= node->getName() ; what+=" is not a child of node "; what += getName();
          throw Exception(what);
        }
    }
  
  const Node *father = node->_father;
  while (father != this)
    {
      nodeName = father->getQualifiedName() + SEP_CHAR_BTW_LEVEL + nodeName;
      father = father->_father;
    }
  return nodeName;
}

References YACS::ENGINE::Node::_father, getName(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Node::getQualifiedName(), isNodeAlreadyAggregated(), and SEP_CHAR_BTW_LEVEL.

◆ getDelegateOf() [1/2]

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

protectedvirtual

Reimplemented in YACS::ENGINE::Loop.

Definition at line 1472 of file ComposedNode.cxx.

1473{

1474}

Referenced by YACS::ENGINE::OutPort::calculateHistoryOfLinkWith(), and edRemoveLink().

◆ getDelegateOf() [2/2]

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

protectedvirtual

Reimplemented in YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::Loop, and YACS::ENGINE::Switch.

Definition at line 1476 of file ComposedNode.cxx.

1477{

1478}

◆ getDeploymentTree()

DeploymentTree ComposedNode::getDeploymentTree ( ) const

virtual

Essentially for test. Use checkDeploymentTree instead to be sure that returned DeploymentTree is consistent.

Implements YACS::ENGINE::Scheduler.

Definition at line 176 of file ComposedNode.cxx.

{
  DeploymentTree ret;
  list< ElementaryNode * > tasks=getRecursiveConstituents();
  for(list< ElementaryNode * >::iterator iter=tasks.begin();iter!=tasks.end();iter++)
    ret.appendTask(*iter,(*iter)->getDynClonerIfExists(this));
  return ret;
}

References YACS::ENGINE::DeploymentTree::appendTask(), and getRecursiveConstituents().

Referenced by performDuplicationOfPlacement(), performShallowDuplicationOfPlacement(), and YACS::ENGINE::Proc::updateContainersAndComponents().

◆ getErrorReport()

std::string ComposedNode::getErrorReport ( )

virtual

returns a string that contains an error report if the node is in error

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop.

Definition at line 1561 of file ComposedNode.cxx.

{
  DEBTRACE("ComposedNode::getErrorReport: " << getName() << " " << _state);
  YACS::StatesForNode effectiveState=getEffectiveState();
 
  if(effectiveState != YACS::INVALID &&  effectiveState != YACS::ERROR && effectiveState != YACS::FAILED)
    return "";
 
  std::string report="<error node= " + getName();
  switch(effectiveState)
    {
    case YACS::INVALID:
      report=report+" state= INVALID";
      break;
    case YACS::ERROR:
      report=report+" state= ERROR";
      break;
    case YACS::FAILED:
      report=report+" state= FAILED";
      break;
    default:
      break;
    }
  report=report + ">\n" ;
  if(_errorDetails != "")
    report=report+_errorDetails+"\n";
 
  list<Node *> constituents=edGetDirectDescendants();
  for(list<Node *>::iterator iter=constituents.begin(); iter!=constituents.end(); iter++)
    {
      std::string rep=(*iter)->getErrorReport();
      if(rep != "")
        {
          report=report+rep+"\n";
        }
    }
  report=report+"</error>";
  return report;
}

References YACS::ENGINE::Node::_errorDetails, YACS::ENGINE::Node::_state, DEBTRACE, edGetDirectDescendants(), YACS::ERROR, YACS::FAILED, YACS::ENGINE::Node::getEffectiveState(), getName(), and YACS::INVALID.

Referenced by main(), and YACS::HMI::EditionProc::synchronize().

◆ getInPortName()

string ComposedNode::getInPortName ( const InPort * inPort ) const

virtual

Get the input port name.

get the input port name used by the current node, recursively built with children names.

Implements YACS::ENGINE::Node.

Definition at line 1200 of file ComposedNode.cxx.

{
  return getPortName<InPort>(inPort);
}

Referenced by YACS::ENGINE::LinkInfo::getErrRepr(), YACS::ENGINE::LinkInfo::getInfoRepr(), YACS::ENGINE::LinkInfo::getWarnRepr(), and YACS::ENGINE::DynParaLoop::prepareInputsFromOutOfScope().

◆ getInputDataStreamPort()

InputDataStreamPort * ComposedNode::getInputDataStreamPort ( const std::string & name ) const

virtual

Implements YACS::ENGINE::Node.

Definition at line 1337 of file ComposedNode.cxx.

{
  string portName, nodeName;
  if(splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,true))
    {
      Node *child = getChildByName(nodeName);
      return child->getInputDataStreamPort(portName);
    }
  else
    {
      string what("ComposedNode::getInputDataStreamPort : the port with name "); what+=name; what+=" does not exist on the current level";
      throw Exception(what);
    }
}

References getChildByName(), YACS::ENGINE::Node::getInputDataStreamPort(), YACS::ENGINE::Node::SEP_CHAR_IN_PORT, and splitNamesBySep().

◆ getInputPort()

InputPort * ComposedNode::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::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::ForLoop, YACS::ENGINE::OptimizerLoop, YACS::ENGINE::Switch, and YACS::ENGINE::WhileLoop.

Definition at line 1297 of file ComposedNode.cxx.

{
  try {
    return Node::getInputPort(name);
  }
  catch(Exception& e) {}
 
  string portName, nodeName;
  if(splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,true))
    {
      Node *child = getChildByName(nodeName);
      return child->getInputPort(portName);
    }
  else
    {
      string what("ComposedNode::getInputPort : the port with name "); what+=name; what+=" does not exist on the current level";
      throw Exception(what);
    }
}

References getChildByName(), YACS::ENGINE::Node::getInputPort(), YACS::ENGINE::Node::SEP_CHAR_IN_PORT, and splitNamesBySep().

Referenced by YACS::ENGINE::DynParaLoop::getInputPort(), YACS::ENGINE::ForLoop::getInputPort(), YACS::ENGINE::Switch::getInputPort(), and YACS::ENGINE::WhileLoop::getInputPort().

◆ getLocalInputPorts()

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

virtual

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

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::ForLoop, YACS::ENGINE::OptimizerLoop, YACS::ENGINE::Switch, and YACS::ENGINE::WhileLoop.

Definition at line 1516 of file ComposedNode.cxx.

{
  std::list<InputPort *> lip; return lip; // empty list
}

Referenced by checkBasicConsistency(), YACS::ENGINE::DynParaLoop::getLocalInputPorts(), YACS::ENGINE::Switch::getLocalInputPorts(), and YACS::HMI::SubjectComposedNode::loadChildren().

◆ getLocalOutputPorts()

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

virtual

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

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::ForLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 1522 of file ComposedNode.cxx.

{
  std::list<OutputPort *> lop; return lop; // empty list
}

Referenced by YACS::ENGINE::DynParaLoop::getLocalOutputPorts(), and YACS::HMI::SubjectComposedNode::loadChildren().

◆ getLowestCommonAncestor()

ComposedNode * ComposedNode::getLowestCommonAncestor	(	Node *	node1,
		Node *	node2
	)

static

Retrieves the lowest common ancestor of 2 nodes.

Note: Retrieves the lowest common ancestor of 'node1' AND 'node2'. If 'node1' or 'node2' are both or indiscriminately instances of ComposedNode and that 'node1' is in descendance of 'node2' (resp. 'node2' in descendance of 'node1') 'node2' is returned (resp. 'node1').

Exceptions

Exception : if 'node1' and 'node2' do not share the same genealogy.

Returns: The lowest common ancestor if it exists.

Definition at line 1050 of file ComposedNode.cxx.

{
  const char what[]="The two nodes do not share the same genealogy";
  if(node1==0 || node2==0)
    throw Exception(what);
  ComposedNode *temp;
  if(dynamic_cast<ComposedNode *>(node1))
    temp=(ComposedNode *)node1;//->_father;
  else
    temp=(ComposedNode *)node1->_father;
  set<ComposedNode *> s;
  while(temp)
    {
      s.insert(temp);
      temp=temp->_father;
    }
  //
  if(dynamic_cast<ComposedNode *>(node2))
    temp=(ComposedNode *)node2;//->_father;
  else
    temp=(ComposedNode *)node2->_father;
  set<ComposedNode *>::iterator iter=s.find(temp);
  while(temp && iter==s.end())
    {
      iter=s.find(temp);
      temp=temp->_father;
    }
  if(iter==s.end())
    throw Exception(what);
  return *iter;
}

References YACS::ENGINE::Node::_father, testCppPluginInvokation::node1, and testCppPluginInvokation::node2.

Referenced by YACS::ENGINE::Bloc::Bloc(), YACS::ENGINE::OutPort::calculateHistoryOfLinkWith(), checkConsistency(), checkLinksCoherenceRegardingControl(), edAddDFLink(), edAddLink(), edRemoveLink(), and YACS::ENGINE::ForEachLoopGen::getFEDeltaBetween().

◆ getLowestCommonAncestorStr()

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

static

Same as getLowestCommonAncestor method except that absolute string representation is considered here instead of instances.

Definition at line 1085 of file ComposedNode.cxx.

{
  std::string ret;
  std::size_t it1_b(0),it1_e(0),it2_b(0),it2_e(0);
  while(it1_b!=std::string::npos && it2_b!=std::string::npos)
    {
      it1_e=node1.find(SEP_CHAR_BTW_LEVEL,it1_b);
      it2_e=node2.find(SEP_CHAR_BTW_LEVEL,it2_b);
      if(it1_e!=it2_e && it1_e!=std::string::npos && it2_e!=std::string::npos)
        break;
      std::string elt1(node1.substr(it1_b,it1_e-it1_b)),elt2(node2.substr(it2_b,it2_e-it2_b));
      if(elt1!=elt2)
        break;
      if(!ret.empty())
        ret+=SEP_CHAR_BTW_LEVEL;
      ret+=elt1;
      it1_b=node1.find_first_not_of(SEP_CHAR_BTW_LEVEL,it1_e);
      it2_b=node2.find_first_not_of(SEP_CHAR_BTW_LEVEL,it2_e);
    }
  return ret;
}

References testCppPluginInvokation::node1, testCppPluginInvokation::node2, and SEP_CHAR_BTW_LEVEL.

◆ getLowestNodeDealingAll()

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

protected

Returns the lowest Node (Elementary or Composed) (is sense of hierachy level ( operator< ) ) containing all 'ports'. Typically use in consistency computation. Precondition : 'ports' must contain at least one element. All elements of 'ports' should be in descendance of 'this'.

Definition at line 700 of file ComposedNode.cxx.

{
  list< OutPort *>::const_iterator iter=ports.begin();
  Node *ret=(*iter)->getNode();
  iter++;
  for(;iter!=ports.end();iter++)
    {
      Node *tmp=(*iter)->getNode();
      if(*tmp>*ret)
        ret=tmp;
    }
  return ret;
}

Referenced by solveObviousOrDelegateCFLinks().

◆ getMyQualifiedName()

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

virtual

Reimplemented in YACS::ENGINE::Switch.

Definition at line 994 of file ComposedNode.cxx.

{
  return directSon->getName();
}

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

Referenced by YACS::ENGINE::Node::getQualifiedName().

◆ getName()

std::string ComposedNode::getName ( ) const

virtual

Implements YACS::ENGINE::Scheduler.

Definition at line 165 of file ComposedNode.cxx.

{
  return Node::getName();
}

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

◆ getNextTasks()

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

virtual

Implements YACS::ENGINE::Scheduler.

Definition at line 217 of file ComposedNode.cxx.

{
  vector<Task *> ret;
  isMore=false;
  getReadyTasks(ret);
  isMore=!ret.empty();
  return ret;
}

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

◆ getNumberOfInputPorts()

int ComposedNode::getNumberOfInputPorts ( ) const

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::Loop, YACS::ENGINE::OptimizerLoop, and YACS::ENGINE::Switch.

Definition at line 1210 of file ComposedNode.cxx.

{
  list<Node *> constituents=edGetDirectDescendants();
  int ret=0;
  for(list<Node *>::iterator iter=constituents.begin();iter!=constituents.end();iter++)
    ret+=(*iter)->getNumberOfInputPorts();
  return ret;
}

References edGetDirectDescendants().

Referenced by YACS::ENGINE::DynParaLoop::getNumberOfInputPorts(), YACS::ENGINE::Loop::getNumberOfInputPorts(), and YACS::ENGINE::Switch::getNumberOfInputPorts().

◆ getNumberOfOutputPorts()

int ComposedNode::getNumberOfOutputPorts ( ) const

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 1219 of file ComposedNode.cxx.

{
  list<Node *> constituents=edGetDirectDescendants();
  int ret=0;
  for(list<Node *>::iterator iter=constituents.begin();iter!=constituents.end();iter++)
    ret+=(*iter)->getNumberOfOutputPorts();
  return ret;
}

References edGetDirectDescendants().

Referenced by YACS::ENGINE::DynParaLoop::getNumberOfOutputPorts().

◆ getOutPort()

OutPort * ComposedNode::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::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::ForLoop, YACS::ENGINE::OptimizerLoop, and YACS::ENGINE::Switch.

Definition at line 1276 of file ComposedNode.cxx.

{
  string portName, nodeName;
  if(splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,false))
    {
      Node *child = getChildByShortName(nodeName);
      return child->getOutPort(portName);
    }
  else
    {
      string what("ComposedNode::getOutPort : the port with name "); what+=name; what+=" does not exist on the current level";
      throw Exception(what);
    }
}

References getChildByShortName(), YACS::ENGINE::Node::getOutPort(), YACS::ENGINE::Node::SEP_CHAR_IN_PORT, and splitNamesBySep().

Referenced by YACS::ENGINE::Bloc::Bloc(), YACS::ENGINE::DynParaLoop::getOutPort(), YACS::ENGINE::ForLoop::getOutPort(), YACS::ENGINE::Switch::getOutPort(), and YACS::ENGINE::WhileLoop::WhileLoop().

◆ getOutPortName()

string ComposedNode::getOutPortName ( const OutPort * outPort ) const

virtual

Implements YACS::ENGINE::Node.

Definition at line 1205 of file ComposedNode.cxx.

{
  return getPortName<OutPort>(outPort);
}

Referenced by YACS::ENGINE::CollectorSwOutPort::CollectorSwOutPort(), YACS::ENGINE::ForEachLoopGen::createOutputOutOfScopeInterceptors(), YACS::ENGINE::ForEachLoopGen::ForEachLoopGen(), YACS::ENGINE::LinkInfo::getErrRepr(), YACS::ENGINE::LinkInfo::getInfoRepr(), and YACS::ENGINE::LinkInfo::getWarnRepr().

◆ getOutputDataStreamPort()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 1352 of file ComposedNode.cxx.

{
  string portName, nodeName;
  if(splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,true))
    {
      Node *child = getChildByName(nodeName);
      return child->getOutputDataStreamPort(portName);
    }
  else
    {
      string what("ComposedNode::getOutputDataStreamPort : the port with name "); what+=name; what+=" does not exist on the current level";
      throw Exception(what);
    }
}

References getChildByName(), YACS::ENGINE::Node::getOutputDataStreamPort(), YACS::ENGINE::Node::SEP_CHAR_IN_PORT, and splitNamesBySep().

◆ getOutputPort()

OutputPort * ComposedNode::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.

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::ForLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 1322 of file ComposedNode.cxx.

{
  string portName, nodeName;
  if(splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,false))
    {
      Node *child = getChildByShortName(nodeName);
      return child->getOutputPort(portName);
    }
  else
    {
      string what("ComposedNode::getOutputPort : the port with name "); what+=name; what+=" does not exist on the current level";
      throw Exception(what);
    }
}

References getChildByShortName(), YACS::ENGINE::Node::getOutputPort(), YACS::ENGINE::Node::SEP_CHAR_IN_PORT, and splitNamesBySep().

Referenced by YACS::ENGINE::DynParaLoop::getOutputPort(), and YACS::ENGINE::ForLoop::getOutputPort().

◆ getPortName()

template<class PORT >

std::string YACS::ENGINE::ComposedNode::getPortName ( const PORT * port ) const

protected

Definition at line 180 of file ComposedNode.hxx.

    {
      Node *node = port->getNode();
      std::string portName = port->getName();  
      checkInMyDescendance(node);
      Node *father = node;
      while (father != this)
        {
          portName = father->getQualifiedName() + Node::SEP_CHAR_IN_PORT + portName;
          father = father->_father;
        }
      return portName;
    }

References YACS::ENGINE::Node::_father, checkInMyDescendance(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Node::getQualifiedName(), and YACS::ENGINE::Node::SEP_CHAR_IN_PORT.

Referenced by YACS::ENGINE::Bloc::Bloc(), YACS::ENGINE::ForEachLoopGen::buildDelegateOf(), YACS::ENGINE::DynParaLoop::DynParaLoop(), YACS::ENGINE::ForLoop::ForLoop(), YACS::ENGINE::ForEachLoopGen::getOutputPortType(), YACS::ENGINE::OptimizerLoop::OptimizerLoop(), YACS::ENGINE::DynParaLoop::putValueOnBranch(), and YACS::ENGINE::WhileLoop::WhileLoop().

◆ getProgress()

virtual std::string YACS::ENGINE::ComposedNode::getProgress ( ) const

inlinevirtual

Reimplemented in YACS::ENGINE::ForEachLoopGen, and YACS::ENGINE::ForLoop.

Definition at line 126 of file ComposedNode.hxx.

126{ return "0"; }

◆ getProgressWeight()

list< ProgressWeight > ComposedNode::getProgressWeight ( ) const

virtual

Get the progress weight for all elementary nodes.

Only elementary nodes have weight. A simple composed node only sum up weight of all his descendants (working is different for loop or switch nodes)

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::ForLoop, and YACS::ENGINE::Switch.

Definition at line 1183 of file ComposedNode.cxx.

{
  list<ProgressWeight> ret;
  list<Node *> setOfNode=edGetDirectDescendants();
  for(list<Node *>::const_iterator iter=setOfNode.begin();iter!=setOfNode.end();iter++)
    {
      list<ProgressWeight> myCurrentSet=((ComposedNode*)(*iter))->getProgressWeight();
      ret.insert(ret.end(),myCurrentSet.begin(),myCurrentSet.end());
    }
  return ret;
}

References edGetDirectDescendants(), and getProgressWeight().

Referenced by YACS::ENGINE::Proc::getGlobalProgressPercent(), and getProgressWeight().

◆ getProperty()

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

overridevirtual

Reimplemented from YACS::ENGINE::Node.

Definition at line 1509 of file ComposedNode.cxx.

{
  return Node::getProperty(name);
}

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

Referenced by YACS::ENGINE::Node::getProperty().

◆ getRecursiveConstituents()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 1121 of file ComposedNode.cxx.

{
  list<ElementaryNode *> ret;
  list<Node *> setOfNode=edGetDirectDescendants();
  for(list<Node *>::const_iterator iter=setOfNode.begin();iter!=setOfNode.end();iter++)
    {
      list<ElementaryNode *> myCurrentSet=(*iter)->getRecursiveConstituents();
      ret.insert(ret.end(),myCurrentSet.begin(),myCurrentSet.end());
    }
  return ret;
}

References edGetDirectDescendants().

Referenced by checkDeploymentTree(), getDeploymentTree(), performDuplicationOfPlacement(), and performShallowDuplicationOfPlacement().

◆ getRootNode()

ComposedNode * ComposedNode::getRootNode ( ) const

virtual

Reimplemented from YACS::ENGINE::Node.

Definition at line 927 of file ComposedNode.cxx.

{
  if(!_father)
    return (ComposedNode *)this;
  return Node::getRootNode();
}

References YACS::ENGINE::Node::_father, and YACS::ENGINE::Node::getRootNode().

Referenced by YACS::HMI::GuiExecutor::updateSchema().

◆ getSetOfInputDataStreamPort()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 1252 of file ComposedNode.cxx.

{
  list<Node *> constituents=edGetDirectDescendants();
  list<InputDataStreamPort *> ret;
  for(list<Node *>::iterator iter=constituents.begin();iter!=constituents.end();iter++)
    {
      list<InputDataStreamPort *> currentsPorts=(*iter)->getSetOfInputDataStreamPort();
      ret.insert(ret.end(),currentsPorts.begin(),currentsPorts.end());
    }
  return ret;
}

References edGetDirectDescendants().

Referenced by YACS::HMI::SubjectComposedNode::loadChildren().

◆ getSetOfInputPort()

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

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::Loop, YACS::ENGINE::OptimizerLoop, and YACS::ENGINE::Switch.

Definition at line 1228 of file ComposedNode.cxx.

{
  list<Node *> constituents=edGetDirectDescendants();
  list<InputPort *> ret;
  for(list<Node *>::iterator iter=constituents.begin();iter!=constituents.end();iter++)
    {
      list<InputPort *> currentsPorts=(*iter)->getSetOfInputPort();
      ret.insert(ret.end(),currentsPorts.begin(),currentsPorts.end());
    }
  return ret;
}

References edGetDirectDescendants().

Referenced by checkConsistency(), YACS::ENGINE::DynParaLoop::getSetOfInputPort(), YACS::ENGINE::Loop::getSetOfInputPort(), and YACS::ENGINE::Switch::getSetOfInputPort().

◆ getSetOfInternalLinks()

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

Definition at line 587 of file ComposedNode.cxx.

{
  vector< pair<OutPort *, InPort *> > ret;
  list<OutPort *> temp=getSetOfOutPort();
  for(list<OutPort *>::const_iterator iter2=temp.begin();iter2!=temp.end();iter2++)
    {
      set<InPort *> temp2=(*iter2)->edSetInPort();
      for(set<InPort *>::iterator iter3=temp2.begin();iter3!=temp2.end();iter3++)
        if(isInMyDescendance((*iter3)->getNode()))
          ret.push_back(pair<OutPort *, InPort *>((*iter2),(*iter3)));
    }
  return ret;
}

References YACS::ENGINE::Node::getSetOfOutPort(), and isInMyDescendance().

Referenced by YACS::ENGINE::Bloc::Bloc(), YACS::ENGINE::ForLoop::ForLoop(), YACS::HMI::SubjectComposedNode::loadLinks(), and YACS::ENGINE::WhileLoop::WhileLoop().

◆ getSetOfLinksComingInCurrentScope()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 835 of file ComposedNode.cxx.

{
  vector< pair<InPort *, OutPort *> > ret;
  set<InPort *> ports=getAllInPortsComingFromOutsideOfCurrentScope();
  for(set<InPort *>::iterator iter2=ports.begin();iter2!=ports.end();iter2++)
    {
      set<OutPort *> temp2=(*iter2)->edSetOutPort();
      for(set<OutPort *>::iterator iter3=temp2.begin();iter3!=temp2.end();iter3++)
        {
          if(isInMyDescendance((*iter3)->getNode()))continue;
          std::set<OutPort *> trueOutPorts;
          (*iter3)->getAllRepresented(trueOutPorts);
          for(std::set<OutPort *>::iterator iter4=trueOutPorts.begin();iter4!=trueOutPorts.end();++iter4)
            ret.push_back(pair<InPort *, OutPort *>(*iter2,*iter4));
        }
    }
  return ret;
}

References getAllInPortsComingFromOutsideOfCurrentScope(), and isInMyDescendance().

Referenced by edDisconnectAllLinksWithMe().

◆ getSetOfLinksLeavingCurrentScope()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 601 of file ComposedNode.cxx.

{
  vector< pair<OutPort *, InPort *> > ret;
  std::set<OutPort *> ports=getAllOutPortsLeavingCurrentScope();
  for(set<OutPort *>::iterator iter2=ports.begin();iter2!=ports.end();iter2++)
    {
      set<InPort *> temp2=(*iter2)->edSetInPort();
      for(set<InPort *>::iterator iter3=temp2.begin();iter3!=temp2.end();iter3++)
        if(!isInMyDescendance((*iter3)->getNode()))
          ret.push_back(pair<OutPort *, InPort *>(*iter2,*iter3));
    }
  return ret;
}

References getAllOutPortsLeavingCurrentScope(), and isInMyDescendance().

Referenced by edDisconnectAllLinksWithMe().

◆ getSetOfOutputDataStreamPort()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 1264 of file ComposedNode.cxx.

{
  list<Node *> constituents=edGetDirectDescendants();
  list<OutputDataStreamPort *> ret;
  for(list<Node *>::iterator iter=constituents.begin();iter!=constituents.end();iter++)
    {
      list<OutputDataStreamPort *> currentsPorts=(*iter)->getSetOfOutputDataStreamPort();
      ret.insert(ret.end(),currentsPorts.begin(),currentsPorts.end());
    }
  return ret;
}

References edGetDirectDescendants().

Referenced by YACS::HMI::SubjectComposedNode::loadChildren().

◆ getSetOfOutputPort()

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

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 1240 of file ComposedNode.cxx.

{
  list<Node *> constituents=edGetDirectDescendants();
  list<OutputPort *> ret;
  for(list<Node *>::iterator iter=constituents.begin();iter!=constituents.end();iter++)
    {
      list<OutputPort *> currentsPorts=(*iter)->getSetOfOutputPort();
      ret.insert(ret.end(),currentsPorts.begin(),currentsPorts.end());
    }
  return ret;
}

References edGetDirectDescendants().

Referenced by YACS::ENGINE::DynParaLoop::getSetOfOutputPort(), and YACS::ENGINE::ForLoop::getSetOfOutputPort().

◆ getTaskName()

std::string ComposedNode::getTaskName ( Task * task ) const

virtual

Implements YACS::ENGINE::Scheduler.

Definition at line 170 of file ComposedNode.cxx.

{
  return getChildName(dynamic_cast<ElementaryNode *>(task));
}

References getChildName().

◆ init()

void ComposedNode::init ( bool start = true )

virtual

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

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::ForLoop, YACS::ENGINE::Loop, YACS::ENGINE::OptimizerLoop, YACS::ENGINE::Switch, YACS::ENGINE::WhileLoop, and YACS::ENGINE::SalomeProc.

Definition at line 160 of file ComposedNode.cxx.

{
  Node::init(start);
}

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

Referenced by YACS::ENGINE::DynParaLoop::init(), YACS::ENGINE::Loop::init(), and YACS::ENGINE::Switch::init().

◆ isFinished()

bool ComposedNode::isFinished ( )

virtual

Implements YACS::ENGINE::Scheduler.

Definition at line 151 of file ComposedNode.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.

Referenced by YACS::ENGINE::OptimizerLoop::isFullyBusy(), YACS::ENGINE::ForEachLoopGen::updateStateForWorkNodeOnFinishedEventFrom(), and YACS::ENGINE::OptimizerLoop::updateStateOnFinishedEventFrom().

◆ isInMyDescendance()

Node * ComposedNode::isInMyDescendance ( Node * nodeToTest ) const

Returns the parent of a node that is the direct child of this node.

Note: if 'nodeToTest'=='this' this is returned. Else if 'nodeToTest' is in descendance of 'this' the direct son is returned. Else 0 is returned.

Parameters

nodeToTest : the node to check

Definition at line 949 of file ComposedNode.cxx.

{
  if(nodeToTest==0)
    return 0;
  if((ComposedNode *)nodeToTest==this)
    return (Node *)this;
  Node *iterBack=nodeToTest;
  ComposedNode *iter=nodeToTest->_father;
  while(iter!=0 && iter!=this)
    {
      iterBack=iter;
      iter=iter->_father;
    }
  if(iter!=0)
    return iterBack;
  else
    return 0;
}

References YACS::ENGINE::Node::_father.

Referenced by YACS::ENGINE::DynParaLoop::buildDelegateOf(), YACS::ENGINE::Loop::buildDelegateOf(), YACS::ENGINE::Bloc::checkCFLinks(), checkCFLinks(), YACS::ENGINE::DynParaLoop::checkCFLinks(), YACS::ENGINE::ForLoop::checkCFLinks(), checkConsistency(), YACS::ENGINE::Bloc::checkControlDependancy(), YACS::ENGINE::DynParaLoop::checkLinkPossibility(), YACS::ENGINE::OptimizerLoop::checkLinkPossibility(), YACS::ENGINE::DynParaLoop::cloneAndPlaceNodesCoherently(), getAllInPortsComingFromOutsideOfCurrentScope(), YACS::ENGINE::Switch::getAllInPortsComingFromOutsideOfCurrentScope(), getAllOutPortsLeavingCurrentScope(), YACS::ENGINE::DynParaLoop::getDynInputPortByAbsName(), YACS::HMI::SceneBlocItem::getNodesInfo(), YACS::ENGINE::Switch::getRankOfNode(), getSetOfInternalLinks(), getSetOfLinksComingInCurrentScope(), getSetOfLinksLeavingCurrentScope(), YACS::ENGINE::OptimizerLoop::initInterceptors(), YACS::HMI::SubjectComposedNode::removeExternalControlLinks(), YACS::ENGINE::VisitorSaveSchema::writeControls(), YACS::ENGINE::VisitorSaveSchema::writeSimpleDataLinks(), and YACS::ENGINE::VisitorSaveSchema::writeSimpleStreamLinks().

◆ isLoop()

virtual bool YACS::ENGINE::ComposedNode::isLoop ( ) const

inlinevirtual

Reimplemented in YACS::ENGINE::DynParaLoop, and YACS::ENGINE::Loop.

Definition at line 79 of file ComposedNode.hxx.

79{ return false; }

Referenced by edAddLink().

◆ isNameAlreadyUsed()

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

virtual

Reimplemented in YACS::ENGINE::Bloc.

Definition at line 1527 of file ComposedNode.cxx.

{
  return false;
}

Referenced by YACS::ENGINE::Node::setName().

◆ isNodeAlreadyAggregated()

bool ComposedNode::isNodeAlreadyAggregated ( const Node * node ) const

Check that Node 'node' is already a direct son of this.

Definition at line 935 of file ComposedNode.cxx.

{
  list<ComposedNode *> nodeAncestors = node->getAllAscendanceOf();
  return find(nodeAncestors.begin(),nodeAncestors.end(),(ComposedNode *)this)!=nodeAncestors.end();
}

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

Referenced by YACS::ENGINE::Bloc::edAddChild(), and getChildName().

◆ isPlacementPredictableB4Run()

virtual bool YACS::ENGINE::ComposedNode::isPlacementPredictableB4Run ( ) const

pure virtual

Implements YACS::ENGINE::Scheduler.

Implemented in YACS::ENGINE::DynParaLoop, and YACS::ENGINE::StaticDefinedComposedNode.

◆ isRepeatedUnpredictablySeveralTimes()

virtual bool YACS::ENGINE::ComposedNode::isRepeatedUnpredictablySeveralTimes ( ) const

inlinevirtual

Reimplemented in YACS::ENGINE::Loop.

Definition at line 78 of file ComposedNode.hxx.

78{ return false; }

◆ loaded()

void ComposedNode::loaded ( )

Definition at line 1488 of file ComposedNode.cxx.

1489{

1490}

◆ notifyFrom()

void ComposedNode::notifyFrom	(	const Task *	sender,
		YACS::Event	event,
		const Executor *	execInst
	)

virtual

Notify the node a task has emitted an event.

TO COMMENT MORE

Note: Runtime called method. Overloads the Scheduler::notifyFrom abstract method. Typically Called in Executor (in a parallel thread or not) by the Task 'task' to inform the scheduler that an event coded 'event' (in Executor static const var) happened. Contrary to updateStateFrom several levels may exist between 'sender' and 'this'.

Parameters

sender	: task emitting event
event	: event emitted

Called by Executor::functionForTaskExecution on YACS::FINISH event

Called by Executor::launchTask on YACS::START event

Calls ComposedNode::updateStateFrom to update state from task to root node

Implements YACS::ENGINE::Scheduler.

Definition at line 243 of file ComposedNode.cxx.

{
  DEBTRACE("ComposedNode::notifyFrom " << event);
  ElementaryNode *taskTyped=dynamic_cast<ElementaryNode *>((Task *)sender);
  YACS::Event curEvent=event;
  Node *lminus1LevelNode=taskTyped;
  ComposedNode *curLevelNode=taskTyped->_father;
  if(!curLevelNode)//Specific case of loop when 0 turn is specified without any enclosing bloc.
    return ;
  curEvent=curLevelNode->updateStateFrom(lminus1LevelNode,curEvent,execInst);
  while(curEvent!=YACS::NOEVENT && curLevelNode!=this)
    {
      lminus1LevelNode=curLevelNode;
      curLevelNode=curLevelNode->_father;
      curEvent=curLevelNode->updateStateFrom(lminus1LevelNode,curEvent,execInst);
    }
}

References YACS::ENGINE::Node::_father, DEBTRACE, YACS::NOEVENT, and updateStateFrom().

◆ performCFComputations()

void ComposedNode::performCFComputations ( LinkInfo & info ) const

protectedvirtual

perform recursively all CF computations.

Reimplemented in YACS::ENGINE::Bloc.

Definition at line 678 of file ComposedNode.cxx.

{
  list<Node *> nodes=edGetDirectDescendants();
  for(list<Node *>::iterator iter=nodes.begin();iter!=nodes.end();iter++)
    if(dynamic_cast<ComposedNode *>(*iter))
      ((ComposedNode *)(*iter))->performCFComputations(info);
}

References edGetDirectDescendants(), and performCFComputations().

Referenced by checkConsistency(), YACS::ENGINE::Bloc::performCFComputations(), and performCFComputations().

◆ performDuplicationOfPlacement()

void ComposedNode::performDuplicationOfPlacement ( const Node & other )

protectedvirtual

performs a duplication of placement using clone method of containers and components. clone behaviour is driven by attachOnCloning attribute.

Implements YACS::ENGINE::Node.

Definition at line 66 of file ComposedNode.cxx.

{
  const ComposedNode &otherC=*(dynamic_cast<const ComposedNode *>(&other));
  DeploymentTree treeToDup=otherC.getDeploymentTree();
  list< ElementaryNode * > clones=otherC.getRecursiveConstituents();
  vector<Container *> conts=treeToDup.getAllContainers();
  //iterate on all containers
  for(vector<Container *>::iterator iterCt=conts.begin();iterCt!=conts.end();iterCt++)
    {
      vector<ComponentInstance *> comps=treeToDup.getComponentsLinkedToContainer(*iterCt);
      Container *contCloned=0;
      if((*iterCt))
        contCloned=(*iterCt)->clone();
 
      //iterate on all component instances linked to the container
      for(vector<ComponentInstance *>::iterator iterCp=comps.begin();iterCp!=comps.end();iterCp++)
        {
          vector<Task *> tasks=treeToDup.getTasksLinkedToComponent(*iterCp);
          ComponentInstance *curCloned=(*iterCp)->clone();
          curCloned->setContainer(contCloned);
          for(vector<Task *>::iterator iterT=tasks.begin();iterT!=tasks.end();iterT++)
            {
              //No risk for static cast : appendTask called by ComposedNode.
              list< ElementaryNode * >::iterator res=find(clones.begin(),clones.end(),(ElementaryNode *)(*iterT));
              //No risk here to because called only on cloning process...
              ServiceNode *nodeC=(ServiceNode *)getChildByName(otherC.getChildName(*res));
              nodeC->setComponent(curCloned);
            }
          curCloned->decrRef();
        }
 
      // iterate on all tasks linked to the container
      vector<Task *> tasks=treeToDup.getTasksLinkedToContainer(*iterCt);
      for(vector<Task *>::iterator iterT=tasks.begin();iterT!=tasks.end();iterT++)
        {
          std::list< ElementaryNode * >::iterator res=find(clones.begin(),clones.end(),(ElementaryNode *)(*iterT));
          InlineFuncNode *nodeC=(InlineFuncNode *)getChildByName(otherC.getChildName(*res));
          nodeC->setContainer(contCloned);
        }
 
      // ended with current container
      if(contCloned)
        contCloned->decrRef();
    }
}

References YACS::ENGINE::ComponentInstance::clone(), YACS::ENGINE::Container::clone(), YACS::ENGINE::RefCounter::decrRef(), YACS::ENGINE::DeploymentTree::getAllContainers(), getChildByName(), getChildName(), YACS::ENGINE::DeploymentTree::getComponentsLinkedToContainer(), getDeploymentTree(), getRecursiveConstituents(), YACS::ENGINE::DeploymentTree::getTasksLinkedToComponent(), YACS::ENGINE::DeploymentTree::getTasksLinkedToContainer(), YACS::ENGINE::ServiceNode::setComponent(), YACS::ENGINE::ComponentInstance::setContainer(), and YACS::ENGINE::InlineNode::setContainer().

◆ performShallowDuplicationOfPlacement()

void ComposedNode::performShallowDuplicationOfPlacement ( const Node & other )

protectedvirtual

performs a also duplication of placement but here containers and components are not copied at all whatever the value of attachedOnCloning.

Implements YACS::ENGINE::Node.

Definition at line 112 of file ComposedNode.cxx.

{
  const ComposedNode &otherC=*(dynamic_cast<const ComposedNode *>(&other));
  DeploymentTree treeToDup=otherC.getDeploymentTree();
  list< ElementaryNode * > clones=otherC.getRecursiveConstituents();
  vector<Container *> conts=treeToDup.getAllContainers();
  //iterate on all containers
  for(vector<Container *>::iterator iterCt=conts.begin();iterCt!=conts.end();iterCt++)
    {
      vector<ComponentInstance *> comps=treeToDup.getComponentsLinkedToContainer(*iterCt);
      Container *contCloned((*iterCt));
 
      //iterate on all component instances linked to the container
      for(vector<ComponentInstance *>::iterator iterCp=comps.begin();iterCp!=comps.end();iterCp++)
        {
          vector<Task *> tasks=treeToDup.getTasksLinkedToComponent(*iterCp);
          ComponentInstance *curCloned((*iterCp));
          curCloned->setContainer(contCloned);
          for(vector<Task *>::iterator iterT=tasks.begin();iterT!=tasks.end();iterT++)
            {
              //No risk for static cast : appendTask called by ComposedNode.
              list< ElementaryNode * >::iterator res=find(clones.begin(),clones.end(),(ElementaryNode *)(*iterT));
              //No risk here to because called only on cloning process...
              ServiceNode *nodeC=(ServiceNode *)getChildByName(otherC.getChildName(*res));
              nodeC->setComponent(curCloned);
            }
        }
 
      // iterate on all tasks linked to the container
      vector<Task *> tasks=treeToDup.getTasksLinkedToContainer(*iterCt);
      for(vector<Task *>::iterator iterT=tasks.begin();iterT!=tasks.end();iterT++)
        {
          std::list< ElementaryNode * >::iterator res=find(clones.begin(),clones.end(),(ElementaryNode *)(*iterT));
          InlineFuncNode *nodeC=(InlineFuncNode *)getChildByName(otherC.getChildName(*res));
          nodeC->setContainer(contCloned);
        }
    }
}

References YACS::ENGINE::DeploymentTree::getAllContainers(), getChildByName(), getChildName(), YACS::ENGINE::DeploymentTree::getComponentsLinkedToContainer(), getDeploymentTree(), getRecursiveConstituents(), YACS::ENGINE::DeploymentTree::getTasksLinkedToComponent(), YACS::ENGINE::DeploymentTree::getTasksLinkedToContainer(), YACS::ENGINE::ServiceNode::setComponent(), YACS::ENGINE::ComponentInstance::setContainer(), and YACS::ENGINE::InlineNode::setContainer().

◆ releaseDelegateOf() [1/2]

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

protectedvirtual

Reimplemented in YACS::ENGINE::Loop.

Definition at line 1480 of file ComposedNode.cxx.

1481{

1482}

Referenced by edRemoveLink().

◆ releaseDelegateOf() [2/2]

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

protectedvirtual

Reimplemented in YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::Loop, and YACS::ENGINE::Switch.

Definition at line 1484 of file ComposedNode.cxx.

1485{

1486}

◆ removeRecursivelyRedundantCL()

void ComposedNode::removeRecursivelyRedundantCL ( )

virtual

This method recursively all redundant control links in this.

Reimplemented in YACS::ENGINE::Bloc.

Definition at line 1110 of file ComposedNode.cxx.

{
  std::list<Node *> dd(edGetDirectDescendants());
  for(std::list<Node *>::const_iterator it=dd.begin();it!=dd.end();it++)
    {
      ComposedNode *elt(dynamic_cast<ComposedNode *>(*it));
      if(elt)
        elt->removeRecursivelyRedundantCL();
    }
}

References edGetDirectDescendants(), and removeRecursivelyRedundantCL().

Referenced by YACS::ENGINE::Bloc::removeRecursivelyRedundantCL(), and removeRecursivelyRedundantCL().

◆ resetState()

void ComposedNode::resetState ( int level )

virtual

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

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::ForEachLoopGen.

Definition at line 1638 of file ComposedNode.cxx.

{
  if(level==0)return;
 
  DEBTRACE("ComposedNode::resetState " << level << "," << _state);
  if( _state==YACS::ERROR || _state==YACS::FAILED || _state==YACS::ACTIVATED )
    {
      Node::resetState(level);
      std::list<Node *> nodes=edGetDirectDescendants();
      for(std::list<Node *>::iterator iter=nodes.begin();iter!=nodes.end();iter++)
        (*iter)->resetState(level);
    }
}

References YACS::ENGINE::Node::_state, YACS::ACTIVATED, DEBTRACE, edGetDirectDescendants(), YACS::ERROR, YACS::FAILED, and YACS::ENGINE::Node::resetState().

Referenced by main(), and YACS::ENGINE::ForEachLoopGen::resetState().

◆ setProperty()

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

overridevirtual

Reimplemented from YACS::ENGINE::Node.

Definition at line 1504 of file ComposedNode.cxx.

{
  Node::setProperty(name, value);
}

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

◆ shutdown()

void ComposedNode::shutdown ( int level )

virtual

Stop all pending activities of the composed node.

This method should be called when a Proc is finished and must be deleted from the YACS server

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DynParaLoop.

Definition at line 1616 of file ComposedNode.cxx.

{
  if(level==0)return;
  DEBTRACE("ComposedNode::shutdown");
  list<Node *> nodes=edGetDirectDescendants();
  for(list<Node *>::iterator iter=nodes.begin();iter!=nodes.end();iter++)
    (*iter)->shutdown(level);
}

References DEBTRACE, and edGetDirectDescendants().

Referenced by Handler(), and main().

◆ solveObviousOrDelegateCFLinks()

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

protected

Internal method during CF links. This methode is in charge to statuate on links consistency in the case that no control flow defined by user is set.

Definition at line 757 of file ComposedNode.cxx.

{
  static const char what[]="ComposedNode::solveObviousOrDelegateCFLinks : Internal error occured - uncorrect hierarchy detected !";
  if(starts.size()==1)
    {
      if(alreadyFed==FREE_ST)
        {
          if(!direction)
            info.pushInfoLink(*(starts.begin()),end,I_BACK);
          alreadyFed=FED_ST;
        }
      else if(alreadyFed==FED_ST)
        info.pushInfoLink(*(starts.begin()),end,direction ?  I_USELESS : I_BACK_USELESS);
      else
        info.pushErrLink(*(starts.begin()),end,E_COLLAPSE_DFDS);
    }
  else
    {
      Node *levelOfDecision=getLowestNodeDealingAll(starts);
      if(levelOfDecision==this)
        throw Exception(what);
      if(dynamic_cast<ElementaryNode *>(levelOfDecision))
        {
          WarnReason reason;
          if(alreadyFed==FREE_ST || alreadyFed==FED_ST)
            {
              if(alreadyFed==FREE_ST)
                {
                  reason=direction ? W_COLLAPSE_EL : W_BACK_COLLAPSE_EL;
                  alreadyFed=FED_ST;
                }
              else
                reason=direction ? W_COLLAPSE_EL_AND_USELESS : W_BACK_COLLAPSE_EL_AND_USELESS;
              for(list< OutPort *>::const_iterator iter=starts.begin();iter!=starts.end();iter++)
                info.pushWarnLink(*iter,end,reason);
            }
        }
      else
        ((ComposedNode *)levelOfDecision)->checkCFLinks(starts,end,alreadyFed,direction,info);
    }
}

References YACS::ENGINE::E_COLLAPSE_DFDS, FED_ST, FREE_ST, getLowestNodeDealingAll(), YACS::ENGINE::I_BACK, YACS::ENGINE::I_BACK_USELESS, YACS::ENGINE::I_USELESS, YACS::ENGINE::LinkInfo::pushErrLink(), 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(), YACS::ENGINE::DynParaLoop::checkCFLinks(), YACS::ENGINE::ForLoop::checkCFLinks(), YACS::ENGINE::Loop::checkCFLinks(), and YACS::ENGINE::OptimizerLoop::checkCFLinks().

◆ splitNamesBySep()

bool ComposedNode::splitNamesBySep	(	const std::string &	globalName,
		const char	separator[],
		std::string &	firstPart,
		std::string &	lastPart,
		bool	priority
	)

staticprotected

Splits name globalName in 2 parts using separator.

Note: 'priority' specifies if during search process of 'separator' the max part is for 'firstPart' (priority=true) or 'lastPart' (priority=false).

Exceptions

Exception : 'lastPart' or 'firstPart' is empty.

Returns: true if split process succeeds false otherwise (typically when character separator was not found).

Definition at line 561 of file ComposedNode.cxx.

{
  const string delims(separator);
  string portName, nodeName;
  string::size_type idx;
  if(priority)
    idx = globalName.find_last_of(delims);
  else
    idx = globalName.find_first_of(delims);
  if (idx == string::npos)
    {
      firstPart=globalName;
      lastPart="";
      return false;
    }
  firstPart = globalName.substr(0,idx);
  lastPart = globalName.substr(idx+1);
  if ((firstPart.empty()) || (lastPart.empty()))
    {
      string what("the name "); what+= globalName ; what+=" is not a valid port name";
      throw Exception(what);
    }
  return true;
}

Referenced by getChildByName(), YACS::ENGINE::DynParaLoop::getDynInputPortByAbsName(), YACS::ENGINE::ForEachLoopGen::getDynOutPortByAbsName(), getInputDataStreamPort(), getInputPort(), getOutPort(), getOutputDataStreamPort(), and getOutputPort().

◆ typeName()

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

inlinevirtual

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::Bloc, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::ForLoop, YACS::ENGINE::Loop, YACS::ENGINE::OptimizerLoop, YACS::ENGINE::Proc, YACS::ENGINE::Switch, YACS::ENGINE::WhileLoop, YACS::ENGINE::SalomeOptimizerLoop, and YACS::ENGINE::SalomeProc.

Definition at line 108 of file ComposedNode.hxx.

108{return "YACS__ENGINE__ComposedNode";}

◆ updateStateFrom()

YACS::Event ComposedNode::updateStateFrom	(	Node *	node,
		YACS::Event	event,
		const Executor *	execInst
	)

protected

Update node state on receiving event from a node.

Note: Runtime called method. Perform, the state updating, from the son node 'node' emitting the event 'event' (among Executor static const var). WARNING Precondition : this == node->_father

Returns: The event (among Executor static const var) destinated to this->_father node to perform eventually up level update.

Calls ComposedNode::updateStateOnStartEventFrom if event is YACS::START

Calls ComposedNode::updateStateOnFinishedEventFrom if event is YACS::FINISH

Called by ComposedNode::notifyFrom

Definition at line 1382 of file ComposedNode.cxx.

{
  DEBTRACE("updateStateFrom: " << node->getName() << " " << event);
  try
    {
      switch(event)
        {
        case YACS::START:
          return updateStateOnStartEventFrom(node);
          break;
        case YACS::FINISH:
          return updateStateOnFinishedEventFrom(node);
          break;
        case YACS::ABORT:
          return updateStateOnFailedEventFrom(node,execInst);
          break;
        default:
          return YACS::NOEVENT;//TODO unexpected type of event
          break;
        }
    }
  catch(YACS::Exception& ex)
    {
      //unexpected exception: probably a bug in engine
      //try to keep a consistent global state
      DEBTRACE( "updateStateFrom: " << ex.what() );
      _errorDetails="Internal error: ";
      _errorDetails=_errorDetails + ex.what();
      setState(YACS::ERROR);
      exForwardFailed();
      return YACS::ABORT;
    }
  catch(...)
    {
      //unexpected exception: probably a bug in engine
      //try to keep a consistent global state
      setState(YACS::ERROR);
      exForwardFailed();
      return YACS::ABORT;
    }
}

References YACS::ENGINE::Node::_errorDetails, YACS::ABORT, DEBTRACE, YACS::ERROR, testCppPluginInvokation::ex, YACS::ENGINE::Node::exForwardFailed(), YACS::FINISH, YACS::ENGINE::Node::getName(), YACS::NOEVENT, YACS::ENGINE::Node::setState(), YACS::START, updateStateOnFailedEventFrom(), updateStateOnFinishedEventFrom(), and updateStateOnStartEventFrom().

Referenced by notifyFrom().

◆ updateStateOnFailedEventFrom()

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

protectedvirtual

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

Reimplemented in YACS::ENGINE::Bloc, YACS::ENGINE::DynParaLoop, YACS::ENGINE::ForEachLoopGen, and YACS::ENGINE::OptimizerLoop.

Definition at line 1441 of file ComposedNode.cxx.

{
   setState(YACS::FAILED);
   return YACS::ABORT;
}

References YACS::ABORT, YACS::FAILED, and YACS::ENGINE::Node::setState().

Referenced by updateStateFrom().

◆ updateStateOnFinishedEventFrom()

virtual YACS::Event YACS::ENGINE::ComposedNode::updateStateOnFinishedEventFrom ( Node * node )

protectedpure virtual

Implemented in YACS::ENGINE::Bloc, YACS::ENGINE::ForEachLoopGen, YACS::ENGINE::ForLoop, YACS::ENGINE::OptimizerLoop, YACS::ENGINE::Switch, and YACS::ENGINE::WhileLoop.

Referenced by updateStateFrom().

◆ updateStateOnStartEventFrom()

YACS::Event ComposedNode::updateStateOnStartEventFrom ( Node * node )

protectedvirtual

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

Update the ComposedNode state and return the ComposedNode change state

Parameters

node	: the child node that has started

Returns: the loop state change

Definition at line 1434 of file ComposedNode.cxx.

{
  setState(YACS::ACTIVATED);
  return YACS::START;
}

References YACS::ACTIVATED, YACS::ENGINE::Node::setState(), and YACS::START.

Referenced by updateStateFrom().

Friends And Related Function Documentation

◆ Bloc

friend class Bloc

friend

Definition at line 44 of file ComposedNode.hxx.

Referenced by YACS::ENGINE::Bloc::simpleClone().

◆ ElementaryNode

friend class ElementaryNode

friend

Definition at line 47 of file ComposedNode.hxx.

◆ Loop

friend class Loop

friend

Definition at line 45 of file ComposedNode.hxx.

◆ OutPort

friend class OutPort

friend

Definition at line 46 of file ComposedNode.hxx.

Member Data Documentation

◆ FED_DS_ST

const unsigned char YACS::ENGINE::ComposedNode::FED_DS_ST = 1

staticprotected

Definition at line 176 of file ComposedNode.hxx.

Referenced by YACS::ENGINE::Bloc::checkCFLinks(), and checkLinksCoherenceRegardingControl().

◆ FED_ST

const unsigned char YACS::ENGINE::ComposedNode::FED_ST = 2

staticprotected

Definition at line 174 of file ComposedNode.hxx.

Referenced by YACS::ENGINE::Bloc::checkCFLinks(), checkCFLinks(), YACS::ENGINE::DynParaLoop::checkCFLinks(), YACS::ENGINE::ForLoop::checkCFLinks(), YACS::ENGINE::Switch::checkCFLinks(), solveObviousOrDelegateCFLinks(), YACS::ENGINE::Bloc::verdictForCollapses(), and YACS::ENGINE::Bloc::verdictForOkAndUseless1().

◆ FREE_ST

const unsigned char YACS::ENGINE::ComposedNode::FREE_ST = 0

staticprotected

Definition at line 175 of file ComposedNode.hxx.

Referenced by YACS::ENGINE::Bloc::checkCFLinks(), YACS::ENGINE::DynParaLoop::checkCFLinks(), YACS::ENGINE::ForLoop::checkCFLinks(), checkLinksCoherenceRegardingControl(), solveObviousOrDelegateCFLinks(), YACS::ENGINE::Bloc::verdictForCollapses(), and YACS::ENGINE::Bloc::verdictForOkAndUseless1().

◆ SEP_CHAR_BTW_LEVEL

const char ComposedNode::SEP_CHAR_BTW_LEVEL ="."

static

Definition at line 49 of file ComposedNode.hxx.

Referenced by YACS::ENGINE::Node::checkValidityOfNodeName(), getChildByName(), getChildName(), and getLowestCommonAncestorStr().

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

src/engine/ComposedNode.hxx
src/engine/ComposedNode.cxx

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Static Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ComposedNode() [1/2]

◆ ComposedNode() [2/2]

◆ ~ComposedNode()

Member Function Documentation

◆ accept()

◆ buildDelegateOf() [1/2]

◆ buildDelegateOf() [2/2]

◆ checkBasicConsistency()

◆ checkCFLinks()

◆ checkConsistency()

◆ checkControlDependancy()

◆ checkDeploymentTree()

◆ checkInMyDescendance()

◆ checkLinkPossibility()

◆ checkLinksCoherenceRegardingControl()

◆ checkNoCrossHierachyWith()

◆ checkNoCyclePassingThrough()

◆ cleanNodes()

◆ connected()

◆ destructCFComputations()

◆ edAddCFLink()

◆ edAddChild()

◆ edAddDFLink()

◆ edAddLink() [1/2]

◆ edAddLink() [2/2]

◆ edDisconnectAllLinksWithMe()

◆ edGetDirectDescendants()

◆ edRemoveCFLink()

◆ edRemoveChild()

◆ edRemoveLink() [1/2]

◆ edRemoveLink() [2/2]

◆ edUpdateState()

◆ getAllInPortsComingFromOutsideOfCurrentScope()

◆ getAllOutPortsLeavingCurrentScope()

◆ getAllRecursiveConstituents()

◆ getAllRecursiveNodes()

◆ getChildByName()

◆ getChildByShortName()

◆ getChildName()

◆ getDelegateOf() [1/2]

◆ getDelegateOf() [2/2]

◆ getDeploymentTree()

◆ getErrorReport()

◆ getInPortName()

◆ getInputDataStreamPort()

◆ getInputPort()

◆ getLocalInputPorts()

◆ getLocalOutputPorts()

◆ getLowestCommonAncestor()

◆ getLowestCommonAncestorStr()

◆ getLowestNodeDealingAll()

◆ getMyQualifiedName()

◆ getName()

◆ getNextTasks()

◆ getNumberOfInputPorts()

◆ getNumberOfOutputPorts()

◆ getOutPort()

◆ getOutPortName()

◆ getOutputDataStreamPort()

◆ getOutputPort()

◆ getPortName()

◆ getProgress()

◆ getProgressWeight()

◆ getProperty()

◆ getRecursiveConstituents()

◆ getRootNode()

◆ getSetOfInputDataStreamPort()

◆ getSetOfInputPort()

◆ getSetOfInternalLinks()