Base class for all calculation nodes. More...

#include <ElementaryNode.hxx>

Inheritance diagram for YACS::ENGINE::ElementaryNode:

[legend]

Collaboration diagram for YACS::ENGINE::ElementaryNode:

[legend]

Public Member Functions
virtual	~ElementaryNode ()

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

void	init (bool start=true)

bool	isDeployable () const

ComponentInstance *	getComponent ()

const ComponentInstance *	getComponent () const

Container *	getContainer ()

YACS::StatesForNode	getState () const

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

void	edRemovePort (Port *port)

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

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

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

virtual void	checkBasicConsistency () const

ComposedNode *	getDynClonerIfExists (const ComposedNode *levelToStop) const

int	getNumberOfInputPorts () const

int	getNumberOfOutputPorts () const

std::string	getInPortName (const InPort *) const

std::string	getOutPortName (const OutPort *) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual InputPort *	createInputPort (const std::string &inputPortName, TypeCode *type)

virtual OutputPort *	createOutputPort (const std::string &outputPortName, TypeCode *type)

virtual InputDataStreamPort *	createInputDataStreamPort (const std::string &inputPortDSName, TypeCode *type)

virtual OutputDataStreamPort *	createOutputDataStreamPort (const std::string &outputPortDSName, TypeCode *type)

virtual InputPort *	edAddInputPort (const std::string &inputPortName, TypeCode *type)

virtual OutputPort *	edAddOutputPort (const std::string &outputPortName, TypeCode *type)

virtual InputDataStreamPort *	edAddInputDataStreamPort (const std::string &inputPortDSName, TypeCode *type)

virtual OutputDataStreamPort *	edAddOutputDataStreamPort (const std::string &outputPortDSName, TypeCode *type)

virtual void	edOrderInputPorts (const std::list< InputPort * > &ports)

virtual void	edOrderOutputPorts (const std::list< OutputPort * > &ports)

virtual std::string	typeName ()

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

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

int	getMaxLevelOfParallelism () const

ComplexWeight *	getWeight ()

void	setWeight (double elementaryWeight)

void	getWeightRegardingDPL (ComplexWeight *weight)

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

void	begin ()

bool	isReady ()

void	finished ()

void	aborted ()

void	loaded ()
	Notify this node that it is loaded. More...

void	connected ()
	Notify this node that it is connected. More...

virtual std::string	getErrorDetails ()
	Give a description of error when node status is ERROR. More...

virtual void	initService ()

virtual void	connectService ()

virtual void	disconnectService ()

virtual void	load ()

virtual void	getCoupledTasks (std::set< Task * > &coupledSet)
	Calls getCoupledNodes for Task interface. More...

virtual void	getCoupledNodes (std::set< Task * > &coupledSet)
	Put all nodes that are coupled to this node in coupledSet. More...

void	accept (Visitor *visitor)

virtual void	addDatastreamPortToInitMultiService (const std::string &port_name, int number)

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

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	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	exFailedState ()
	Notify this node that its execution has failed. More...

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

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

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

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

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

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

InPropertyPort *	getInPropertyPort () const

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

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

bool	operator> (const Node &other) const

bool	operator< (const Node &other) const

std::string	getImplementation () const

DynParaLoop *	getClosestDPLAmongAncestors () const

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 Proc *	getProc ()

virtual const Proc *	getProc () const

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

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

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

virtual void	applyDPLScope (ComposedNode *gfn)

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

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

virtual std::string	getErrorDetails () const

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

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

virtual int	isModified ()

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

virtual std::string	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	cleanNodes ()
	Clean the node in case of not clean exit. More...

Public Member Functions inherited from YACS::ENGINE::Task
virtual void	execute ()=0

virtual void	imposeResource (const std::string &resource_name, const std::string &container_name)

virtual bool	canAcceptImposedResource ()

virtual bool	hasImposedResource () const

virtual	~Task ()

Protected Member Functions
	ElementaryNode (const std::string &name)

	ElementaryNode (const ElementaryNode &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	initCommonPartWithoutStateManagement (bool start)

virtual void	createMultiDatastreamPorts ()

void	edDisconnectAllLinksWithMe ()

bool	areAllInputPortsValid () const

template<class PORT >
PORT *	getPort (const std::string &name, const std::list< PORT * > &setOfPorts) const

template<class PORT , class ENUMTYPE >
PORT *	edAddPort (const std::string &portName, std::list< PORT * > &setOfPorts, ENUMTYPE type)

template<class PORT , class ENUMTYPE >
bool	edCheckAddPort (const std::string &portName, std::list< PORT * > &setOfPorts, ENUMTYPE type)

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

	Node (const Node &other, ComposedNode *father)

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

virtual void	exForwardFailed ()

virtual void	exForwardFinished ()

Static Protected Member Functions
template<class PORT >
static void	edRemovePortTypedFromSet (PORT port, std::list< PORT > &setOfPorts)

template<class PORT >
static bool	isPortNameAlreadyExist (const std::string &portName, const std::list< PORT * > &setOfPorts)

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

static ComposedNode *	checkHavingCommonFather (Node node1, Node node2)

Protected Attributes
std::list< InputPort * >	_setOfInputPort

std::list< OutputPort * >	_setOfOutputPort

std::list< InputDataStreamPort * >	_setOfInputDataStreamPort

std::list< OutputDataStreamPort * >	_setOfOutputDataStreamPort

ComplexWeight	_weight

bool	_createDatastreamPorts

bool	_multi_port_node

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

Friends
class	ComposedNode

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

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

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

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

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

static int	_total = 0

Detailed Description

Base class for all calculation nodes.

This is an abstract class that must be specialized.

Definition at line 43 of file ElementaryNode.hxx.

Constructor & Destructor Documentation

◆ ElementaryNode() [1/2]

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

protected

Definition at line 47 of file ElementaryNode.cxx.

                                                    :
   Node(name),
   _createDatastreamPorts(false),
   _multi_port_node(false),
   _weight()
 {
   _weight.setDefaultElementary();
 }

References _weight, and YACS::ENGINE::ComplexWeight::setDefaultElementary().

◆ ElementaryNode() [2/2]

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

protected

Definition at line 56 of file ElementaryNode.cxx.

                                                                                :Node(other,father), _weight(other._weight)
 {
   _createDatastreamPorts = other._createDatastreamPorts;
   _multi_port_node = other._multi_port_node;
   for(list<InputPort *>::const_iterator iter1=other._setOfInputPort.begin();iter1!=other._setOfInputPort.end();iter1++)
     _setOfInputPort.push_back((InputPort *)(*iter1)->clone(this));
   for(list<OutputPort *>::const_iterator iter2=other._setOfOutputPort.begin();iter2!=other._setOfOutputPort.end();iter2++)
     _setOfOutputPort.push_back((OutputPort *)(*iter2)->clone(this));
   for(list<InputDataStreamPort *>::const_iterator iter3=other._setOfInputDataStreamPort.begin();iter3!=other._setOfInputDataStreamPort.end();iter3++)
     _setOfInputDataStreamPort.push_back((InputDataStreamPort *)(*iter3)->clone(this));
   for(list<OutputDataStreamPort *>::const_iterator iter4=other._setOfOutputDataStreamPort.begin();iter4!=other._setOfOutputDataStreamPort.end();iter4++)
     _setOfOutputDataStreamPort.push_back((OutputDataStreamPort *)(*iter4)->clone(this));
 }

References _createDatastreamPorts, _multi_port_node, _setOfInputDataStreamPort, _setOfInputPort, _setOfOutputDataStreamPort, and _setOfOutputPort.

◆ ~ElementaryNode()

ElementaryNode::~ElementaryNode ( )

virtual

Definition at line 78 of file ElementaryNode.cxx.

 {
   for(list<InputPort *>::iterator iter1=_setOfInputPort.begin();iter1!=_setOfInputPort.end();iter1++)
     delete *iter1;
   for(list<OutputPort *>::iterator iter2=_setOfOutputPort.begin();iter2!=_setOfOutputPort.end();iter2++)
     delete *iter2;
   for(list<InputDataStreamPort *>::iterator iter3=_setOfInputDataStreamPort.begin();iter3!=_setOfInputDataStreamPort.end();iter3++)
     delete *iter3;
   for(list<OutputDataStreamPort *>::iterator iter4=_setOfOutputDataStreamPort.begin();iter4!=_setOfOutputDataStreamPort.end();iter4++)
     delete *iter4;
 }

References _setOfInputDataStreamPort, _setOfInputPort, _setOfOutputDataStreamPort, and _setOfOutputPort.

Member Function Documentation

◆ aborted()

void ElementaryNode::aborted ( )

virtual

Implements YACS::ENGINE::Task.

Reimplemented in YACS::ENGINE::FakeNodeForSwitch, YACS::ENGINE::FakeNodeForOptimizerLoop, YACS::ENGINE::FakeNodeForLoop, and YACS::ENGINE::FakeNodeForForEachLoop.

Definition at line 763 of file ElementaryNode.cxx.

 {
   setState(ERROR);
 }

References YACS::ERROR, and YACS::ENGINE::Node::setState().

◆ accept()

void ElementaryNode::accept ( Visitor * visitor )

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::StudyOutNode, YACS::ENGINE::StudyInNode, YACS::ENGINE::PresetNode, YACS::ENGINE::OutNode, YACS::ENGINE::ServiceNode, YACS::ENGINE::ServiceInlineNode, YACS::ENGINE::ServerNode, YACS::ENGINE::InlineFuncNode, and YACS::ENGINE::InlineNode.

Definition at line 795 of file ElementaryNode.cxx.

 {
   visitor->visitElementaryNode(this);
 }

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

◆ addDatastreamPortToInitMultiService()

virtual void YACS::ENGINE::ElementaryNode::addDatastreamPortToInitMultiService	(	const std::string &	port_name,
		int	number
	)

inlinevirtual

Definition at line 134 of file ElementaryNode.hxx.

135 {}

Referenced by createMultiDatastreamPorts().

◆ areAllInputPortsValid()

bool ElementaryNode::areAllInputPortsValid ( ) const

protected

checks if all input ports contains a valid data. Used at execution to change the state of the node for activation.

Definition at line 274 of file ElementaryNode.cxx.

 {
   bool ret=true;
   for(list<InputPort *>::const_iterator iter=_setOfInputPort.begin();iter!=_setOfInputPort.end();iter++)
     {
       ret=!(*iter)->isEmpty();
       if (!ret) break;
     }
   return ret;
 }

References _setOfInputPort.

Referenced by connected(), and exUpdateState().

◆ begin()

void ElementaryNode::begin ( )

virtual

Implements YACS::ENGINE::Task.

Definition at line 749 of file ElementaryNode.cxx.

 {
   setState(ACTIVATED);
 }

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

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

◆ checkBasicConsistency()

void ElementaryNode::checkBasicConsistency ( ) const

virtual

Reimplemented in YACS::ENGINE::StudyOutNode, YACS::ENGINE::StudyInNode, YACS::ENGINE::PyFuncNode, YACS::ENGINE::PythonNode, YACS::ENGINE::PresetNode, YACS::ENGINE::OutNode, and YACS::ENGINE::InlineFuncNode.

Definition at line 577 of file ElementaryNode.cxx.

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

References _setOfInputPort, and DEBTRACE.

Referenced by YACS::ENGINE::InlineFuncNode::checkBasicConsistency(), YACS::ENGINE::PythonNode::checkBasicConsistency(), and edUpdateState().

◆ connected()

void ElementaryNode::connected ( )

virtual

Notify this node that it is connected.

When an elementary node has been connected it goes to TOACTIVATE state It is then ready to be executed

Implements YACS::ENGINE::Task.

Definition at line 784 of file ElementaryNode.cxx.

 {
   if(_inGate.exIsReady())
     if(areAllInputPortsValid())
       {
         setState(TOACTIVATE);
         return;
       }
   setState(LOADED);
 }

References YACS::ENGINE::Node::_inGate, areAllInputPortsValid(), YACS::ENGINE::InGate::exIsReady(), YACS::LOADED, YACS::ENGINE::Node::setState(), and YACS::TOACTIVATE.

◆ connectService()

virtual void YACS::ENGINE::ElementaryNode::connectService ( )

inlinevirtual

Implements YACS::ENGINE::Task.

Definition at line 125 of file ElementaryNode.hxx.

125 { }

◆ createInputDataStreamPort()

InputDataStreamPort * ElementaryNode::createInputDataStreamPort	(	const std::string &	inputPortDSName,
		TypeCode *	type
	)

virtual

Definition at line 689 of file ElementaryNode.cxx.

 {
   return getRuntime()->createInputDataStreamPort(inputPortDSName, this, type);
 }

References YACS::ENGINE::Runtime::createInputDataStreamPort(), and YACS::ENGINE::getRuntime().

Referenced by edAddInputDataStreamPort().

◆ createInputPort()

InputPort * ElementaryNode::createInputPort	(	const std::string &	inputPortName,
		TypeCode *	type
	)

virtual

Reimplemented in YACS::ENGINE::StudyOutNode, and YACS::ENGINE::OutNode.

Definition at line 593 of file ElementaryNode.cxx.

 {
   return getRuntime()->createInputPort(inputPortName, _implementation, this, type);
 }

References YACS::ENGINE::Node::_implementation, YACS::ENGINE::Runtime::createInputPort(), and YACS::ENGINE::getRuntime().

Referenced by edAddInputPort().

◆ createMultiDatastreamPorts()

void ElementaryNode::createMultiDatastreamPorts ( )

protectedvirtual

Definition at line 290 of file ElementaryNode.cxx.

 {
   if (!_createDatastreamPorts)
   {
     _createDatastreamPorts = true;
     for(list<InputDataStreamPort *>::const_iterator iter3 = _setOfInputDataStreamPort.begin(); iter3!=_setOfInputDataStreamPort.end();iter3++)
     {
       InputDataStreamPort * port = *iter3;
       std::string port_name = port->getName();
       std::map<std::string,std::string>::iterator it=_propertyMap.find(port_name);
       int multi = 1;
       if(it != _propertyMap.end())
       {
         std::string multi_str = it->second;
         std::istringstream iss(multi_str);
         if (!(iss >> multi))
           throw Exception("Property multi port should be set with a stringified int not an: " + multi_str);
       }
  
       if (multi > 1)
       {
         addDatastreamPortToInitMultiService(port_name, multi);
         // Change name of first port
         port->setName(port_name + "_0");
         for (int i = 2; i <= multi; i++)
         {
           InputDataStreamPort * new_port = port->clone(this);
           std::ostringstream number;
           number << i-1;
           new_port->setName(port_name + "_" + number.str());
           _setOfInputDataStreamPort.push_back(new_port);
           _multi_port_node = true;
         }
       }
     }
     for(list<OutputDataStreamPort *>::const_iterator iter4 = _setOfOutputDataStreamPort.begin(); iter4!=_setOfOutputDataStreamPort.end();iter4++)
     {
       OutputDataStreamPort * port = *iter4;
       std::string port_name = port->getName();
       std::map<std::string,std::string>::iterator it=_propertyMap.find(port_name);
       int multi = 1;
       if(it != _propertyMap.end())
       {
         std::string multi_str = it->second;
         std::istringstream iss(multi_str);
         if (!(iss >> multi))
           throw Exception("Property multi port should be set with a stringified int not an: " + multi_str);
       }
  
       if (multi > 1)
       {
         addDatastreamPortToInitMultiService(port_name, multi);
         // Change name of first port
         port->setName(port_name + "_0");
         for (int i = 2; i <= multi; i++)
         {
           OutputDataStreamPort * new_port = port->clone(this);
           std::ostringstream number;
           number << i-1;
           new_port->setName(port_name + "_" + number.str());
           _setOfOutputDataStreamPort.push_back(new_port);
           _multi_port_node = true;
         }
       }
     }
   }
 }

References _createDatastreamPorts, _multi_port_node, YACS::ENGINE::Node::_propertyMap, _setOfInputDataStreamPort, _setOfOutputDataStreamPort, addDatastreamPortToInitMultiService(), YACS::ENGINE::InputDataStreamPort::clone(), YACS::ENGINE::OutputDataStreamPort::clone(), YACS::ENGINE::DataPort::getName(), yacsorb.CORBAEngineTest::i, and YACS::ENGINE::DataPort::setName().

Referenced by getReadyTasks().

◆ createOutputDataStreamPort()

OutputDataStreamPort * ElementaryNode::createOutputDataStreamPort	(	const std::string &	outputPortDSName,
		TypeCode *	type
	)

virtual

Definition at line 706 of file ElementaryNode.cxx.

 {
   return getRuntime()->createOutputDataStreamPort(outputPortDSName, this, type);
 }

References YACS::ENGINE::Runtime::createOutputDataStreamPort(), and YACS::ENGINE::getRuntime().

Referenced by edAddOutputDataStreamPort().

◆ createOutputPort()

OutputPort * ElementaryNode::createOutputPort	(	const std::string &	outputPortName,
		TypeCode *	type
	)

virtual

Reimplemented in YACS::ENGINE::StudyInNode, and YACS::ENGINE::PresetNode.

Definition at line 662 of file ElementaryNode.cxx.

 {
   return getRuntime()->createOutputPort(outputPortName, _implementation, this, type);
 }

References YACS::ENGINE::Node::_implementation, YACS::ENGINE::Runtime::createOutputPort(), and YACS::ENGINE::getRuntime().

Referenced by edAddOutputPort().

◆ disconnectService()

virtual void YACS::ENGINE::ElementaryNode::disconnectService ( )

inlinevirtual

Implements YACS::ENGINE::Task.

Definition at line 126 of file ElementaryNode.hxx.

126 { }

◆ edAddInputDataStreamPort()

InputDataStreamPort * ElementaryNode::edAddInputDataStreamPort	(	const std::string &	inputPortDSName,
		TypeCode *	type
	)

virtual

Definition at line 694 of file ElementaryNode.cxx.

 {
   InputDataStreamPort *ret = 0;
   if (edCheckAddPort<InputDataStreamPort, TypeCode*>(inputPortDSName,_setOfInputDataStreamPort,type))
     {
       ret = createInputDataStreamPort(inputPortDSName, type);
       _setOfInputDataStreamPort.push_back(ret);
       modified();
     }
   return ret;
 }

References _setOfInputDataStreamPort, createInputDataStreamPort(), and YACS::ENGINE::Node::modified().

Referenced by YACS::ENGINE::SessionCataLoader::importComponent(), and YACS::HMI::CommandAddIDSPortFromCatalog::localExecute().

◆ edAddInputPort()

InputPort * ElementaryNode::edAddInputPort	(	const std::string &	inputPortName,
		TypeCode *	type
	)

virtual

the input port is also published recursively in ancestors because it may be visible from everywhere. WARNING: CHECK CASE OF BLOC: ONLY INPUT PORTS NOT INTERNALLY CONNECTED MUST BE VISIBLE.

Definition at line 603 of file ElementaryNode.cxx.

 {
  
   // Cannot create an InputPort defined with InPropertyPort name.
   if (inputPortName == "__InPropertyPort__Node__YACS_")
   {
     string what("ElementaryNode::edAddInputPort: it is forbidden to add an InputPort with the name __InPropertyPort__Node__YACS_\"");
     throw Exception(what);
   }
  
   InputPort *ret = 0;
   if (edCheckAddPort<InputPort, TypeCode*>(inputPortName,_setOfInputPort,type))
     {
       ret = createInputPort(inputPortName, type);
       _setOfInputPort.push_back(ret);
       modified();
       /*
       ComposedNode *iter=_father;
       while(iter)
         iter=iter->_father;
         */
     }
   return ret;
 }

References _setOfInputPort, createInputPort(), and YACS::ENGINE::Node::modified().

Referenced by YACS::ENGINE::SessionCataLoader::importComponent(), YACS::inlinetypeParser< T >::inport(), and YACS::HMI::CommandAddInputPortFromCatalog::localExecute().

◆ edAddOutputDataStreamPort()

OutputDataStreamPort * ElementaryNode::edAddOutputDataStreamPort	(	const std::string &	outputPortDSName,
		TypeCode *	type
	)

virtual

Definition at line 711 of file ElementaryNode.cxx.

 {
   OutputDataStreamPort *ret = 0;
   if (edCheckAddPort<OutputDataStreamPort, TypeCode*>(outputPortDSName,_setOfOutputDataStreamPort,type))
     {
       ret = createOutputDataStreamPort(outputPortDSName, type);
       _setOfOutputDataStreamPort.push_back(ret);
       modified();
     }
   return ret;
 }

References _setOfOutputDataStreamPort, createOutputDataStreamPort(), and YACS::ENGINE::Node::modified().

Referenced by YACS::ENGINE::SessionCataLoader::importComponent(), and YACS::HMI::CommandAddODSPortFromCatalog::localExecute().

◆ edAddOutputPort()

OutputPort * ElementaryNode::edAddOutputPort	(	const std::string &	outputPortName,
		TypeCode *	type
	)

virtual

TO SOLVE : The output port is not published in father. Father must create an output port. for now, publication is done the same way as input ports

Definition at line 672 of file ElementaryNode.cxx.

 {
   OutputPort *ret =0;
   if (edCheckAddPort<OutputPort, TypeCode*>(outputPortName,_setOfOutputPort,type))
     {
       ret = createOutputPort(outputPortName, type);
       _setOfOutputPort.push_back(ret);
       modified();
       /*
       ComposedNode *iter=_father;
       while(iter)
         iter=iter->_father;
         */
     }
   return ret;
 }

References _setOfOutputPort, createOutputPort(), and YACS::ENGINE::Node::modified().

Referenced by YACS::ENGINE::SessionCataLoader::importComponent(), YACS::HMI::CommandAddOutputPortFromCatalog::localExecute(), and YACS::inlinetypeParser< T >::outport().

◆ edAddPort()

template<class PORT , class ENUMTYPE >

PORT * YACS::ENGINE::ElementaryNode::edAddPort	(	const std::string &	portName,
		std::list< PORT * > &	setOfPorts,
		ENUMTYPE	type
	)

protected

protected: add a port given it's name and type, in a given list of ports WHY TEMPLATE PARAMETER ENUMTYPE?

Definition at line 179 of file ElementaryNode.hxx.

     {
       checkValidityOfPortName(portName);
       if(isPortNameAlreadyExist<PORT>(portName, setOfPorts))
         {
           std::string what="Port of type "; what+=PORT::NAME; what += " with name : "; what+=portName; what+=" already exists";
           throw Exception(what);
         }
       PORT *ret=new PORT(portName,this,type);
       setOfPorts.push_back(ret);
       return ret;
     }

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

◆ edCheckAddPort()

template<class PORT , class ENUMTYPE >

bool YACS::ENGINE::ElementaryNode::edCheckAddPort	(	const std::string &	portName,
		std::list< PORT * > &	setOfPorts,
		ENUMTYPE	type
	)

protected

Definition at line 193 of file ElementaryNode.hxx.

     {
       checkValidityOfPortName(portName);
       if(isPortNameAlreadyExist<PORT>(portName, setOfPorts))
         {
           std::string what="Port of type "; what+=PORT::NAME; what += " with name : "; what+=portName; what+=" already exists";
           throw Exception(what);
         }
       return true;
     }

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

◆ edDisconnectAllLinksWithMe()

void ElementaryNode::edDisconnectAllLinksWithMe ( )

protectedvirtual

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

Reimplemented from YACS::ENGINE::Node.

Definition at line 249 of file ElementaryNode.cxx.

 {
   //CF
   Node::edDisconnectAllLinksWithMe();
   //Leaving part
   // - DF
   for(list<InputPort *>::iterator iter=_setOfInputPort.begin();iter!=_setOfInputPort.end();iter++)
     (*iter)->edRemoveAllLinksLinkedWithMe();
   // - DS
   for(list<InputDataStreamPort *>::iterator iter2=_setOfInputDataStreamPort.begin();iter2!=_setOfInputDataStreamPort.end();iter2++)
     (*iter2)->edRemoveAllLinksLinkedWithMe();
   //Arriving part
   // - DF
   for(list<OutputPort *>::iterator iter=_setOfOutputPort.begin();iter!=_setOfOutputPort.end();iter++)
     (*iter)->edRemoveAllLinksLinkedWithMe();
   // - DS
   for(list<OutputDataStreamPort *>::iterator iter2=_setOfOutputDataStreamPort.begin();iter2!=_setOfOutputDataStreamPort.end();iter2++)
     (*iter2)->edRemoveAllLinksLinkedWithMe();
 }

References _setOfInputDataStreamPort, _setOfInputPort, _setOfOutputDataStreamPort, _setOfOutputPort, and YACS::ENGINE::Node::edDisconnectAllLinksWithMe().

Referenced by YACS::ENGINE::DFToDSForLoop::~DFToDSForLoop(), and YACS::ENGINE::DSToDFForLoop::~DSToDFForLoop().

◆ edOrderInputPorts()

void ElementaryNode::edOrderInputPorts ( const std::list< InputPort * > & ports )

virtual

Definition at line 628 of file ElementaryNode.cxx.

 {
   std::set<InputPort *> s1;
   std::set<InputPort *> s2;
   for(list<InputPort *>::const_iterator it=_setOfInputPort.begin();it != _setOfInputPort.end();it++)
     s1.insert(*it);
   for(list<InputPort *>::const_iterator it=ports.begin();it != ports.end();it++)
     s2.insert(*it);
  
   if(s1 != s2)
     throw Exception("ElementaryNode::edOrderInputPorts : port list must contain same ports as existing ones");
  
   _setOfInputPort.clear();
   for(list<InputPort *>::const_iterator it=ports.begin();it != ports.end();it++)
     _setOfInputPort.push_back(*it);
 }

References _setOfInputPort.

Referenced by YACS::HMI::CommandOrderInputPorts::localExecute(), and YACS::HMI::CommandOrderInputPorts::localReverse().

◆ edOrderOutputPorts()

void ElementaryNode::edOrderOutputPorts ( const std::list< OutputPort * > & ports )

virtual

Definition at line 645 of file ElementaryNode.cxx.

 {
   std::set<OutputPort *> s1;
   std::set<OutputPort *> s2;
   for(list<OutputPort *>::const_iterator it=_setOfOutputPort.begin();it != _setOfOutputPort.end();it++)
     s1.insert(*it);
   for(list<OutputPort *>::const_iterator it=ports.begin();it != ports.end();it++)
     s2.insert(*it);
  
   if(s1 != s2)
     throw Exception("ElementaryNode::edOrderOutputPorts : port list must contain same ports as existing ones");
  
   _setOfOutputPort.clear();
   for(list<OutputPort *>::const_iterator it=ports.begin();it != ports.end();it++)
     _setOfOutputPort.push_back(*it);
 }

References _setOfOutputPort.

Referenced by YACS::HMI::CommandOrderOutputPorts::localExecute(), and YACS::HMI::CommandOrderOutputPorts::localReverse().

◆ edRemovePort()

void ElementaryNode::edRemovePort ( Port * port )

remove port from node at edition. Ports are typed.

Definition at line 523 of file ElementaryNode.cxx.

 {
   DEBTRACE("ElementaryNode::edRemovePort ");
   if(port->getNode()!=this)
     throw Exception("ElementaryNode::edRemovePort : Port is not held by this node");
   if(InputPort *p=dynamic_cast<InputPort *>(port))
     edRemovePortTypedFromSet<InputPort>(p,_setOfInputPort);
   else if(OutputPort *p=dynamic_cast<OutputPort *>(port))
     edRemovePortTypedFromSet<OutputPort>(p,_setOfOutputPort);
   else if(InputDataStreamPort *p=dynamic_cast<InputDataStreamPort *>(port))
     edRemovePortTypedFromSet<InputDataStreamPort>(p,_setOfInputDataStreamPort);
   else if(OutputDataStreamPort *p=dynamic_cast<OutputDataStreamPort *>(port))
     edRemovePortTypedFromSet<OutputDataStreamPort>(p,_setOfOutputDataStreamPort);
   else
     throw Exception("ElementaryNode::edRemovePort : unknown port type");
   delete port;
   modified();
 }

References _setOfInputDataStreamPort, _setOfInputPort, _setOfOutputDataStreamPort, _setOfOutputPort, DEBTRACE, YACS::ENGINE::Port::getNode(), YACS::ENGINE::Node::modified(), and p.

Referenced by YACS::HMI::SubjectDataPort::~SubjectDataPort().

◆ edRemovePortTypedFromSet()

template<class PORT >

void YACS::ENGINE::ElementaryNode::edRemovePortTypedFromSet	(	PORT *	port,
		std::list< PORT * > &	setOfPorts
	)

staticprotected

protected: remove a port from a given list

Definition at line 209 of file ElementaryNode.hxx.

     {
       if(!isPortNameAlreadyExist<PORT>(port->getName(), setOfPorts))
         throw Exception("Port is not part of the list : unable to remove it");
       typename std::list<PORT *>::iterator iter=std::find(setOfPorts.begin(),setOfPorts.end(),port);
       if(iter!=setOfPorts.end())
         {
           (*iter)->edRemoveAllLinksLinkedWithMe();
           setOfPorts.erase(iter);
         }
     }

◆ edUpdateState()

void ElementaryNode::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 809 of file ElementaryNode.cxx.

 {
   DEBTRACE("ElementaryNode::edUpdateState: " << getName());
   YACS::StatesForNode state=YACS::READY;
   try
     {
       checkBasicConsistency();
       _errorDetails="";
     }
   catch(Exception& e)
     {
       state=YACS::INVALID;
       _errorDetails=e.what();
     }
   DEBTRACE("ElementaryNode::edUpdateState: " << _errorDetails);
   if(state != _state)
     setState(state);
   _modified=0;
 }

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

◆ ensureLoading()

void ElementaryNode::ensureLoading ( )

virtual

Put this node into TOLOAD state when possible.

Can be called by another ElementaryNode that is connected to this one by a datastream link These 2 nodes must be loaded at the same time as they are coupled It's the other node which requests this node loading

Reimplemented from YACS::ENGINE::Node.

Definition at line 835 of file ElementaryNode.cxx.

 {
   DEBTRACE("ElementaryNode::ensureLoading: " << getName());
   if(_state != YACS::READY)
     return;
   setState(YACS::TOLOAD);
  
   // request loading for all nodes connected to this one by datastream link
   // Be careful that nodes can be connected in a loop. Put first this node in TOLOAD state to break the loop
   std::list<OutputDataStreamPort *>::iterator iterout;
   for(iterout = _setOfOutputDataStreamPort.begin(); iterout != _setOfOutputDataStreamPort.end(); iterout++)
     {
       OutputDataStreamPort *port=(OutputDataStreamPort *)*iterout;
       std::set<InPort *> ports=port->edSetInPort();
       std::set<InPort *>::iterator iter;
       for(iter=ports.begin();iter != ports.end(); iter++)
         {
           Node* node= (*iter)->getNode();
           node->ensureLoading();
         }
     }
   std::list<InputDataStreamPort *>::iterator iterin;
   for(iterin = _setOfInputDataStreamPort.begin(); iterin != _setOfInputDataStreamPort.end(); iterin++)
     {
       InputDataStreamPort *port=(InputDataStreamPort *)*iterin;
       std::set<OutPort *> ports=port->edSetOutPort();
       std::set<OutPort *>::iterator iter;
       for(iter=ports.begin();iter != ports.end(); iter++)
         {
           Node* node= (*iter)->getNode();
           node->ensureLoading();
         }
     }
 }

References _setOfInputDataStreamPort, _setOfOutputDataStreamPort, YACS::ENGINE::Node::_state, DEBTRACE, YACS::ENGINE::OutputDataStreamPort::edSetInPort(), YACS::ENGINE::InPort::edSetOutPort(), YACS::ENGINE::Node::ensureLoading(), YACS::ENGINE::Node::getName(), YACS::READY, YACS::ENGINE::Node::setState(), and YACS::TOLOAD.

Referenced by exUpdateState().

◆ exUpdateState()

void ElementaryNode::exUpdateState ( )

virtual

Update the node state.

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

Called by InGate::exNotifyFromPrecursor

Reimplemented from YACS::ENGINE::Node.

Definition at line 136 of file ElementaryNode.cxx.

 {
   DEBTRACE("ElementaryNode::exUpdateState: " << getName() << " " << _state );
   if(_state==YACS::DISABLED)return;
   if(_inGate.exIsReady())
     if(areAllInputPortsValid())
       {
         if(_state == YACS::READY)
           ensureLoading();
         else if(_state == YACS::LOADED)
           setState(YACS::TOACTIVATE);
       }
     else
       {
         string what("ElementaryNode::exUpdateState : Invalid graph given : Node with name \"");
         what+=_name; what+="\" ready to run whereas some inputports are not set correctly\nCheck coherence DF/CF";
         setState(YACS::INTERNALERR);
         _errorDetails=what;
         throw Exception(what);
       }
 }

References YACS::ENGINE::Node::_errorDetails, YACS::ENGINE::Node::_inGate, YACS::ENGINE::Node::_name, YACS::ENGINE::Node::_state, areAllInputPortsValid(), DEBTRACE, YACS::DISABLED, ensureLoading(), YACS::ENGINE::InGate::exIsReady(), YACS::ENGINE::Node::getName(), YACS::INTERNALERR, YACS::LOADED, YACS::READY, YACS::ENGINE::Node::setState(), and YACS::TOACTIVATE.

Referenced by getReadyTasks().

◆ finished()

void ElementaryNode::finished ( )

virtual

Implements YACS::ENGINE::Task.

Reimplemented in YACS::ENGINE::FakeNodeForSwitch, YACS::ENGINE::FakeNodeForOptimizerLoop, YACS::ENGINE::FakeNodeForLoop, and YACS::ENGINE::FakeNodeForForEachLoop.

Definition at line 759 of file ElementaryNode.cxx.

 {
   setState(DONE);
 }

References YACS::DONE, and YACS::ENGINE::Node::setState().

◆ getAllInPortsComingFromOutsideOfCurrentScope()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 195 of file ElementaryNode.cxx.

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

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

Referenced by getSetOfLinksComingInCurrentScope().

◆ getAllOutPortsLeavingCurrentScope()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 182 of file ElementaryNode.cxx.

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

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

Referenced by getSetOfLinksLeavingCurrentScope().

◆ getChildByName()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 571 of file ElementaryNode.cxx.

 {
   string what("ElementaryNode does not agregate any nodes particullary node with name "); what+=name;
   throw Exception(what);
 }

◆ getComponent() [1/2]

ComponentInstance * ElementaryNode::getComponent ( )

virtual

Implements YACS::ENGINE::Task.

Reimplemented in YACS::ENGINE::ServiceNode.

Definition at line 116 of file ElementaryNode.cxx.

 {
   return 0;
 }

◆ getComponent() [2/2]

const ComponentInstance * ElementaryNode::getComponent ( ) const

virtual

Implements YACS::ENGINE::Task.

Reimplemented in YACS::ENGINE::ServiceNode.

Definition at line 121 of file ElementaryNode.cxx.

 {
   return 0;
 }

◆ getContainer()

Container * ElementaryNode::getContainer ( )

virtual

Implements YACS::ENGINE::Task.

Reimplemented in YACS::ENGINE::ServiceNode, and YACS::ENGINE::InlineNode.

Definition at line 126 of file ElementaryNode.cxx.

 {
   return 0;
 }

Referenced by getReadyTasks().

◆ getCoupledNodes()

void ElementaryNode::getCoupledNodes ( std::set< Task * > & coupledSet )

virtual

Put all nodes that are coupled to this node in coupledSet.

Reimplemented from YACS::ENGINE::Node.

Definition at line 877 of file ElementaryNode.cxx.

 {
   if(coupledSet.find(this) != coupledSet.end())return;
  
   coupledSet.insert(this);
  
   std::list<OutputDataStreamPort *>::iterator iterout;
   for(iterout = _setOfOutputDataStreamPort.begin(); iterout != _setOfOutputDataStreamPort.end(); iterout++)
     {
       OutputDataStreamPort *port=(OutputDataStreamPort *)*iterout;
       std::set<InPort *> ports=port->edSetInPort();
       std::set<InPort *>::iterator iter;
       for(iter=ports.begin();iter != ports.end(); iter++)
         {
           Node* node= (*iter)->getNode();
           node->getCoupledNodes(coupledSet);
         }
     }
 }

References _setOfOutputDataStreamPort, YACS::ENGINE::OutputDataStreamPort::edSetInPort(), and YACS::ENGINE::Node::getCoupledNodes().

Referenced by getCoupledTasks().

◆ getCoupledTasks()

void ElementaryNode::getCoupledTasks ( std::set< Task * > & coupledSet )

virtual

Calls getCoupledNodes for Task interface.

Implements YACS::ENGINE::Task.

Definition at line 871 of file ElementaryNode.cxx.

 {
   getCoupledNodes(coupledSet);
 }

References getCoupledNodes().

◆ getDynClonerIfExists()

ComposedNode * ElementaryNode::getDynClonerIfExists ( const ComposedNode * levelToStop ) const

Definition at line 585 of file ElementaryNode.cxx.

 {
   for(ComposedNode *iter=_father;iter!=levelToStop && iter!=0; iter=iter->_father)
     if(!iter->isPlacementPredictableB4Run())
       return iter;
   return 0;
 }

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

◆ getErrorDetails()

std::string ElementaryNode::getErrorDetails ( )

virtual

Give a description of error when node status is ERROR.

Definition at line 804 of file ElementaryNode.cxx.

 {
   return _errorDetails;
 }

References YACS::ENGINE::Node::_errorDetails.

Referenced by YACS::ENGINE::DistributedPythonNode::dealException(), and YACS::ENGINE::SalomeNode::execute().

◆ getInPortName()

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

virtual

get the input port name used by the current node (see composed nodes)

Implements YACS::ENGINE::Node.

Definition at line 727 of file ElementaryNode.cxx.

 {
   Node *node = inPort->getNode();
   if ( node != this ) 
     {
       string what("InputPort "); what += inPort->getName(); what += " does not belong to node "; what += node->getName();
       throw Exception(what);
     }
   return inPort->getName();
 }

References YACS::ENGINE::DataPort::getName(), YACS::ENGINE::Node::getName(), and YACS::ENGINE::Port::getNode().

◆ getInputDataStreamPort()

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

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DSToDFForLoop.

Definition at line 239 of file ElementaryNode.cxx.

 {
   return getPort<InputDataStreamPort>(name,_setOfInputDataStreamPort);
 }

References _setOfInputDataStreamPort.

Referenced by getReadyTasks(), and YACS::HMI::CommandAddIDSPortFromCatalog::localReverse().

◆ getInputPort()

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

virtual

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DFToDSForLoop, and YACS::ENGINE::SplitterNode.

Definition at line 168 of file ElementaryNode.cxx.

 {
   try {
     return Node::getInputPort(name);
   }
   catch(Exception& e) {}
   return getPort<InputPort>(name,_setOfInputPort);
 }

References _setOfInputPort, and YACS::ENGINE::Node::getInputPort().

Referenced by YACS::ENGINE::SplitterNode::getInputPort(), getReadyTasks(), YACS::HMI::CommandOrderInputPorts::localExecute(), YACS::HMI::CommandAddInputPortFromCatalog::localReverse(), YACS::HMI::CommandOrderInputPorts::localReverse(), and YACS::ENGINE::portParser::onEnd().

◆ getLocalInputPorts()

std::list<InputPort *> YACS::ENGINE::ElementaryNode::getLocalInputPorts ( ) const

inlinevirtual

Implements YACS::ENGINE::Node.

Definition at line 85 of file ElementaryNode.hxx.

85 { return _setOfInputPort; }

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

◆ getLocalOutputPorts()

std::list<OutputPort *> YACS::ENGINE::ElementaryNode::getLocalOutputPorts ( ) const

inlinevirtual

Implements YACS::ENGINE::Node.

Definition at line 86 of file ElementaryNode.hxx.

86 { return _setOfOutputPort; }

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

◆ getMaxLevelOfParallelism()

int YACS::ENGINE::ElementaryNode::getMaxLevelOfParallelism ( ) const

inlinevirtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::InlineNode.

Definition at line 110 of file ElementaryNode.hxx.

110 { return 1; }

◆ getNumberOfInputPorts()

int ElementaryNode::getNumberOfInputPorts ( ) const

virtual

Implements YACS::ENGINE::Node.

Definition at line 158 of file ElementaryNode.cxx.

 {
   return _setOfInputPort.size();
 }

References _setOfInputPort.

Referenced by YACS::ENGINE::DistributedPythonNode::execute(), YACS::ENGINE::SalomePythonNode::execute(), YACS::ENGINE::PyFuncNode::executeLocal(), and YACS::ENGINE::PyFuncNode::executeRemote().

◆ getNumberOfOutputPorts()

int ElementaryNode::getNumberOfOutputPorts ( ) const

virtual

Implements YACS::ENGINE::Node.

Definition at line 163 of file ElementaryNode.cxx.

 {
   return _setOfOutputPort.size();
 }

References _setOfOutputPort.

Referenced by YACS::ENGINE::DistributedPythonNode::execute(), YACS::ENGINE::SalomePythonNode::execute(), YACS::ENGINE::XmlNode::execute(), YACS::ENGINE::PyFuncNode::executeLocal(), YACS::ENGINE::PythonNode::executeRemote(), and YACS::ENGINE::PyFuncNode::executeRemote().

◆ getOutPortName()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 738 of file ElementaryNode.cxx.

 {
   Node *node = outPort->getNode();
   if ( node != this ) 
     {
       string what("OutputPort "); what += outPort->getName(); what += " does not belong to node "; what += node->getName();
       throw Exception(what);
     }
   return outPort->getName();
 }

References YACS::ENGINE::DataPort::getName(), YACS::ENGINE::Node::getName(), and YACS::ENGINE::Port::getNode().

◆ getOutputDataStreamPort()

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

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DFToDSForLoop.

Definition at line 244 of file ElementaryNode.cxx.

 {
   return getPort<OutputDataStreamPort>(name,_setOfOutputDataStreamPort);
 }

References _setOfOutputDataStreamPort.

Referenced by getReadyTasks(), and YACS::HMI::CommandAddODSPortFromCatalog::localReverse().

◆ getOutputPort()

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

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DSToDFForLoop.

Definition at line 177 of file ElementaryNode.cxx.

 {
   return getPort<OutputPort>(name,_setOfOutputPort);
 }

References _setOfOutputPort.

Referenced by YACS::HMI::CommandOrderOutputPorts::localExecute(), YACS::HMI::CommandAddOutputPortFromCatalog::localReverse(), and YACS::HMI::CommandOrderOutputPorts::localReverse().

◆ getPort()

template<class PORT >

PORT * YACS::ENGINE::ElementaryNode::getPort	(	const std::string &	name,
		const std::list< PORT * > &	setOfPorts
	)		const

protected

protected: get a port in a list given it's name

Definition at line 160 of file ElementaryNode.hxx.

     {
       for(typename std::list<PORT *>::const_iterator iter=setOfPorts.begin();iter!=setOfPorts.end();iter++)
         {
           if((*iter)->getName()==name)
             return *iter;
         }
       std::string what="ElementaryNode::getPort : unexisting "; what+=PORT::NAME;
       what+=" with name ";
       what+=name;
       throw Exception(what);
     }

◆ getProgressWeight()

list< ProgressWeight > ElementaryNode::getProgressWeight ( ) const

virtual

Get the progress weight for all elementary nodes.

Only elementary nodes have weight. At this stage weight is 0 or 1 (it can be modified later following the kind of father)

Implements YACS::ENGINE::Node.

Definition at line 558 of file ElementaryNode.cxx.

 {
   list<ProgressWeight> ret;
   ProgressWeight myWeight;
   myWeight.weightTotal=1;
   if (getState() == YACS::DONE)
     myWeight.weightDone=1;
   else
     myWeight.weightDone=0;
   ret.push_back(myWeight);
   return ret;
 }

References YACS::DONE, getState(), YACS::ENGINE::ProgressWeight::weightDone, and YACS::ENGINE::ProgressWeight::weightTotal.

◆ getReadyTasks()

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

virtual

add this node task to a given set of ready tasks, if this task is ready to activate

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::DSToDFForLoop, and YACS::ENGINE::DFToDSForLoop.

Definition at line 362 of file ElementaryNode.cxx.

 {
   DEBTRACE("ElementaryNode::getReadyTasks: " << getName() << " " << _state);
  
   int multi = 1;
   std::map<std::string,std::string>::iterator it=_propertyMap.find("multi");
   if(it != _propertyMap.end())
   {
     std::string multi_str = it->second;
     std::istringstream iss(multi_str);
     if (!(iss >> multi))
       throw Exception("Property multi should be set with a stringified int not an: " + multi_str);
   }
  
   if(_state==YACS::TOACTIVATE || _state==YACS::TOLOAD || _state==YACS::TORECONNECT)
   {
     if (multi == 1)
     {
       std::map<std::string,std::string>::iterator it=_propertyMap.find("multi_working_dir");
       if(it != _propertyMap.end())
       {
         std::string working_dir_base = it->second;
         std::ostringstream working_dir_stream;
         working_dir_stream << working_dir_base;
         working_dir_stream << 1;
         this->getContainer()->setProperty("workingdir", working_dir_stream.str());
       }
       tasks.push_back(this);
     }
     else
     {
  
       // Check output port -> cannot clone an Elementary Node with Output Ports connected
       std::list<OutputPort *>::iterator it_output = _setOfOutputPort.begin();
       for (;it_output != _setOfOutputPort.end(); it_output++)
       {
         if ((*it_output)->isConnected())
         {
           throw Exception("Property multi cannot be set on nodes with dataflow output ports connected");
         }
       }
  
       // Add my instance
       std::map<std::string,std::string>::iterator it=_propertyMap.find("multi_working_dir");
       if(it != _propertyMap.end())
       {
         std::string working_dir_base = it->second;
         std::ostringstream working_dir_stream;
         working_dir_stream << working_dir_base;
         working_dir_stream << 1;
         this->getContainer()->setProperty("workingdir", working_dir_stream.str());
       }
       tasks.push_back(this);
  
       // Step 1: Create clones
       for (int i = 1; i < multi; i++)
       {
         // Clone
         YACS::ENGINE::ElementaryNode * new_node = static_cast<YACS::ENGINE::ElementaryNode *>(clone(_father, false));
         new_node->createMultiDatastreamPorts();
  
         // Change name
         std::string iname;
         std::stringstream inamess;
         inamess << getName() << "_" << i;
         iname=inamess.str();
         DEBTRACE("Create clone "<< iname << " of node " << getName());
         new_node->setName(iname);
  
         // For each input port connect it with the original output port
         std::list<InputPort *> clone_list_inputPorts = new_node->getSetOfInputPort();
         for(list<InputPort *>::const_iterator iter1=clone_list_inputPorts.begin(); iter1!=clone_list_inputPorts.end(); iter1++)
         {
           std::string input_port_name = (*iter1)->getName();
           // Get Port Name in master node
           InputPort * master_port = getInputPort(input_port_name);
           for (auto itt : master_port->_backLinks)
           {
             // Connect dataflow
             getProc()->edAddDFLink(itt.first,(*iter1));
           }
         }
  
         // InputDataStreamPort connections
         std::list<InputDataStreamPort *> clone_list_inputDatastreamPorts = new_node->getSetOfInputDataStreamPort();
         for(list<InputDataStreamPort *>::iterator iter = clone_list_inputDatastreamPorts.begin(); iter != clone_list_inputDatastreamPorts.end(); iter++)
         {
           std::string port_name = (*iter)->getName();
           InputDataStreamPort * orig_port = getInputDataStreamPort(port_name);
  
           std::set<OutputDataStreamPort *> connected_ports = orig_port->getConnectedOutputDataStreamPort();
  
           // Create datastream ports if not created
           std::set<OutputDataStreamPort *>::const_iterator iter3;
           for(iter3=connected_ports.begin();iter3!=connected_ports.end();iter3++)
           {
             ElementaryNode * node = (ElementaryNode *) (*iter3)->getNode();
             node->createMultiDatastreamPorts();
  
             std::string good_port_name;
             std::stringstream temp_name;
             std::string out_name = (*iter3)->getName();
             out_name.erase(out_name.end()-1);
             temp_name << out_name << i;
             good_port_name = temp_name.str();
             getProc()->edAddLink(node->getOutputDataStreamPort(good_port_name), (*iter));
           }
         }
  
         // OutputDataStreamPort connections
         std::list<OutputDataStreamPort *> clone_list_outputDatastreamPorts = new_node->getSetOfOutputDataStreamPort();
         for(list<OutputDataStreamPort *>::iterator iter = clone_list_outputDatastreamPorts.begin(); iter != clone_list_outputDatastreamPorts.end(); iter++)
         {
           std::string port_name = (*iter)->getName();
           OutputDataStreamPort * orig_port = getOutputDataStreamPort(port_name);
           std::set<InputDataStreamPort *> dest_input_port = orig_port->_setOfInputDataStreamPort;
           for(set<InputDataStreamPort *>::iterator dest_port = dest_input_port.begin(); dest_port != dest_input_port.end(); dest_port++)
           {
             ElementaryNode * dest_node = (ElementaryNode *)(*dest_port)->getNode();
             // Add InputPort to dest node
             dest_node->createMultiDatastreamPorts();
  
             std::string good_port_name;
             std::stringstream temp_name;
             std::string in_name = (*dest_port)->getName();
             in_name.erase(in_name.end()-1);
             temp_name << in_name << i;
             good_port_name = temp_name.str();
             getProc()->edAddLink((*iter), dest_node->getInputDataStreamPort(good_port_name));
           }
         }
  
         // Init node
         new_node->init(false);
         new_node->exUpdateState();
  
         // Set Control Link to done
         std::list<OutGate *> clone_cl_back = new_node->getInGate()->getBackLinks();
         for(std::list<OutGate *>::const_iterator iter=clone_cl_back.begin(); iter!=clone_cl_back.end(); iter++)
           new_node->getInGate()->exNotifyFromPrecursor((*iter));
  
         // Add clone
         std::map<std::string,std::string>::iterator it=_propertyMap.find("multi_working_dir");
         if(it != _propertyMap.end())
         {
           std::string working_dir_base = it->second;
           std::ostringstream working_dir_stream;
           working_dir_stream << working_dir_base;
           working_dir_stream << i+1;
           new_node->getContainer()->setProperty("workingdir", working_dir_stream.str());
         }
         tasks.push_back(new_node);
       }
     }
   }
 }

References YACS::ENGINE::InPort::_backLinks, YACS::ENGINE::Node::_father, YACS::ENGINE::Node::_propertyMap, YACS::ENGINE::OutputDataStreamPort::_setOfInputDataStreamPort, _setOfOutputPort, YACS::ENGINE::Node::_state, YACS::ENGINE::Node::clone(), createMultiDatastreamPorts(), DEBTRACE, YACS::ENGINE::ComposedNode::edAddDFLink(), YACS::ENGINE::ComposedNode::edAddLink(), YACS::ENGINE::InGate::exNotifyFromPrecursor(), exUpdateState(), YACS::ENGINE::InGate::getBackLinks(), YACS::ENGINE::InputDataStreamPort::getConnectedOutputDataStreamPort(), getContainer(), YACS::ENGINE::Node::getInGate(), getInputDataStreamPort(), getInputPort(), YACS::ENGINE::Node::getName(), getOutputDataStreamPort(), YACS::ENGINE::Node::getProc(), getSetOfInputDataStreamPort(), getSetOfInputPort(), getSetOfOutputDataStreamPort(), yacsorb.CORBAEngineTest::i, init(), YACS::ENGINE::Node::setName(), YACS::ENGINE::Container::setProperty(), YACS::TOACTIVATE, YACS::TOLOAD, and YACS::TORECONNECT.

Referenced by YACS::ENGINE::ForEachLoopGen::getReadyTasks(), YACS::ENGINE::Loop::getReadyTasks(), YACS::ENGINE::OptimizerLoop::getReadyTasks(), and YACS::ENGINE::Switch::getReadyTasks().

◆ getRecursiveConstituents()

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

virtual

Returns: a set with only this node. (Same method in composed nodes)

Implements YACS::ENGINE::Node.

Definition at line 546 of file ElementaryNode.cxx.

 {
   list<ElementaryNode *> ret;
   ret.push_back((ElementaryNode *)this);
   return ret;
 }

◆ getSetOfInputDataStreamPort()

std::list<InputDataStreamPort *> YACS::ENGINE::ElementaryNode::getSetOfInputDataStreamPort ( ) const

inlinevirtual

Implements YACS::ENGINE::Node.

Definition at line 91 of file ElementaryNode.hxx.

91 { return _setOfInputDataStreamPort; }

Referenced by getReadyTasks(), and YACS::HMI::SubjectElementaryNode::loadChildren().

◆ getSetOfInputPort()

std::list<InputPort *> YACS::ENGINE::ElementaryNode::getSetOfInputPort ( ) const

inlinevirtual

Implements YACS::ENGINE::Node.

Definition at line 83 of file ElementaryNode.hxx.

83 { return _setOfInputPort; }

Referenced by getReadyTasks(), YACS::HMI::CommandOrderInputPorts::localExecute(), YACS::HMI::CommandOrderInputPorts::localReverse(), YACS::HMI::TablePortsEdition::on_pb_insert_clicked(), YACS::HMI::EditionPyFunc::onTemplate(), YACS::HMI::SubjectDataPort::registerUndoDestroy(), YACS::HMI::SchemaNodeItem::update(), YACS::ENGINE::VisitorSaveState::visitElementaryNode(), YACS::ENGINE::VisitorSaveSalomeSchema::writeOutNodeParameters(), and YACS::ENGINE::VisitorSaveSalomeSchema::writeStudyOutNodeParameters().

◆ getSetOfLinksComingInCurrentScope()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 221 of file ElementaryNode.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++)
         {
           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().

◆ getSetOfLinksLeavingCurrentScope()

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

virtual

Implements YACS::ENGINE::Node.

Definition at line 208 of file ElementaryNode.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++)
         ret.push_back(pair<OutPort *, InPort *>(*iter2,*iter3));
     }
   return ret;
 }

References getAllOutPortsLeavingCurrentScope().

◆ getSetOfOutputDataStreamPort()

std::list<OutputDataStreamPort *> YACS::ENGINE::ElementaryNode::getSetOfOutputDataStreamPort ( ) const

inlinevirtual

Implements YACS::ENGINE::Node.

Definition at line 92 of file ElementaryNode.hxx.

92 { return _setOfOutputDataStreamPort; }

Referenced by getReadyTasks(), and YACS::HMI::SubjectElementaryNode::loadChildren().

◆ getSetOfOutputPort()

std::list<OutputPort *> YACS::ENGINE::ElementaryNode::getSetOfOutputPort ( ) const

inlinevirtual

Implements YACS::ENGINE::Node.

Definition at line 84 of file ElementaryNode.hxx.

84 { return _setOfOutputPort; }

Referenced by YACS::HMI::CommandOrderOutputPorts::localExecute(), YACS::HMI::CommandOrderOutputPorts::localReverse(), YACS::HMI::TablePortsEdition::on_pb_insert_clicked(), YACS::HMI::EditionPyFunc::onTemplate(), YACS::HMI::SubjectDataPort::registerUndoDestroy(), YACS::HMI::SchemaNodeItem::update(), YACS::ENGINE::VisitorSaveState::visitElementaryNode(), YACS::ENGINE::VisitorSaveSalomeSchema::writeDataNodeParameters(), and YACS::ENGINE::VisitorSaveSalomeSchema::writeStudyInNodeParameters().

◆ getState()

YACS::StatesForNode ElementaryNode::getState ( ) const

virtual

Reimplemented from YACS::ENGINE::Node.

Definition at line 131 of file ElementaryNode.cxx.

 {
   return Node::getState();
 }

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

◆ getWeight()

ComplexWeight* YACS::ENGINE::ElementaryNode::getWeight ( )

inline

Definition at line 111 of file ElementaryNode.hxx.

111 { return &_weight; }

Referenced by YACS::ENGINE::VisitorSaveSchema::visitInlineFuncNode(), and YACS::ENGINE::VisitorSaveSchema::visitInlineNode().

◆ getWeightRegardingDPL()

void YACS::ENGINE::ElementaryNode::getWeightRegardingDPL ( ComplexWeight * weight )

inlinevirtual

Implements YACS::ENGINE::Node.

Definition at line 113 of file ElementaryNode.hxx.

113 { weight->addWeight(getWeight()); }

YACS::ENGINE::ElementaryNode::getWeight

ComplexWeight * getWeight()

Definition: ElementaryNode.hxx:111

References YACS::ENGINE::ComplexWeight::addWeight().

◆ init()

void ElementaryNode::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::PyFuncNode, and YACS::ENGINE::SplitterNode.

Definition at line 99 of file ElementaryNode.cxx.

 {
   DEBTRACE("ElementaryNode::init " << getName() << " " << start << " " << _state);
   initCommonPartWithoutStateManagement(start);
   if(_state == YACS::DISABLED)
     {
       exDisabledState(); // to refresh propagation of DISABLED state
       return ;
     }
   setState(YACS::READY);
 }

References YACS::ENGINE::Node::_state, DEBTRACE, YACS::DISABLED, YACS::ENGINE::Node::exDisabledState(), YACS::ENGINE::Node::getName(), initCommonPartWithoutStateManagement(), YACS::READY, and YACS::ENGINE::Node::setState().

Referenced by getReadyTasks(), and YACS::ENGINE::SplitterNode::init().

◆ initCommonPartWithoutStateManagement()

void ElementaryNode::initCommonPartWithoutStateManagement ( bool start )

protected

Definition at line 90 of file ElementaryNode.cxx.

 {
   for(list<OutputPort *>::iterator iter=_setOfOutputPort.begin();iter!=_setOfOutputPort.end();iter++)
     (*iter)->exInit();
   for(list<InputPort *>::iterator iter2=_setOfInputPort.begin();iter2!=_setOfInputPort.end();iter2++)
     (*iter2)->exInit(start);
   _inGate.exReset();
 }

References YACS::ENGINE::Node::_inGate, _setOfInputPort, _setOfOutputPort, and YACS::ENGINE::InGate::exReset().

Referenced by init(), and YACS::ENGINE::PyFuncNode::init().

◆ initService()

virtual void YACS::ENGINE::ElementaryNode::initService ( )

inlinevirtual

Implements YACS::ENGINE::Task.

Definition at line 124 of file ElementaryNode.hxx.

124 { }

◆ isDeployable()

bool ElementaryNode::isDeployable ( ) const

virtual

Implements YACS::ENGINE::Task.

Reimplemented in YACS::ENGINE::ServiceNode, YACS::ENGINE::ServerNode, and YACS::ENGINE::InlineNode.

Definition at line 111 of file ElementaryNode.cxx.

 {
   return false;
 }

◆ isPortNameAlreadyExist()

template<class PORT >

bool YACS::ENGINE::ElementaryNode::isPortNameAlreadyExist	(	const std::string &	portName,
		const std::list< PORT * > &	setOfPorts
	)

staticprotected

protected: checks existence of a port, given it's name, in a list

Definition at line 226 of file ElementaryNode.hxx.

     {
       for(typename std::list<PORT *>::const_iterator iter=setOfPorts.begin();iter!=setOfPorts.end();iter++)
         {
           if((*iter)->getName()==portName)
             return true;
         }
       return false;
     }

◆ isReady()

bool ElementaryNode::isReady ( )

virtual

Implements YACS::ENGINE::Task.

Definition at line 754 of file ElementaryNode.cxx.

 {
   return _state==TOACTIVATE;
 }

References YACS::ENGINE::Node::_state, and YACS::TOACTIVATE.

◆ load()

virtual void YACS::ENGINE::ElementaryNode::load ( )

inlinevirtual

Implements YACS::ENGINE::Task.

Reimplemented in YACS::ENGINE::XmlNode, YACS::ENGINE::SalomePythonNode, YACS::ENGINE::PyFuncNode, YACS::ENGINE::PythonNode, YACS::ENGINE::DistributedPythonNode, YACS::ENGINE::CppNode, YACS::ENGINE::ServiceNode, YACS::ENGINE::ServerNode, YACS::ENGINE::DSToDFForLoop, and YACS::ENGINE::DFToDSForLoop.

Definition at line 127 of file ElementaryNode.hxx.

127 { }

◆ loaded()

void ElementaryNode::loaded ( )

virtual

Notify this node that it is loaded.

When an elementary node has been loaded It is ready to be connected

Implements YACS::ENGINE::Task.

Definition at line 774 of file ElementaryNode.cxx.

775 {

776 }

◆ partitionRegardingDPL()

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

inlinevirtual

Implements YACS::ENGINE::Node.

Definition at line 114 of file ElementaryNode.hxx.

114 { }

◆ performDuplicationOfPlacement()

void ElementaryNode::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.

Reimplemented in YACS::ENGINE::ServiceNode, and YACS::ENGINE::InlineNode.

Definition at line 70 of file ElementaryNode.cxx.

71 {

72 }

◆ performShallowDuplicationOfPlacement()

void ElementaryNode::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.

Reimplemented in YACS::ENGINE::ServiceNode, and YACS::ENGINE::InlineNode.

Definition at line 74 of file ElementaryNode.cxx.

75 {

76 }

◆ setWeight()

void ElementaryNode::setWeight ( double elementaryWeight )

Definition at line 897 of file ElementaryNode.cxx.

 {
   if(elementaryWeight<=0.)
     throw Exception("ElementaryNode::setWeight : invalid input value !");
   _weight.setElementaryWeight(elementaryWeight);
 }

References _weight, and YACS::ENGINE::ComplexWeight::setElementaryWeight().

Referenced by YACS::inlinetypeParser< T >::function(), YACS::remotetypeParser< T >::function(), and YACS::remotetypeParser< T >::script().

◆ typeName()

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

inlinevirtual

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::StudyOutNode, YACS::ENGINE::StudyInNode, YACS::ENGINE::PyFuncNode, YACS::ENGINE::PythonNode, YACS::ENGINE::PresetNode, YACS::ENGINE::DistributedPythonNode, YACS::ENGINE::SalomeNode, YACS::ENGINE::CORBANode, YACS::ENGINE::ServiceNode, YACS::ENGINE::ServiceInlineNode, YACS::ENGINE::ServerNode, YACS::ENGINE::InlineFuncNode, YACS::ENGINE::InlineNode, and YACS::ENGINE::DataNode.

Definition at line 106 of file ElementaryNode.hxx.

106 {return "YACS__ENGINE__ElementaryNode";}

Friends And Related Function Documentation

◆ ComposedNode

friend class ComposedNode

friend

Definition at line 45 of file ElementaryNode.hxx.

Member Data Documentation

◆ _createDatastreamPorts

bool YACS::ENGINE::ElementaryNode::_createDatastreamPorts

protected

Definition at line 54 of file ElementaryNode.hxx.

Referenced by createMultiDatastreamPorts(), and ElementaryNode().

◆ _multi_port_node

bool YACS::ENGINE::ElementaryNode::_multi_port_node

protected

Definition at line 55 of file ElementaryNode.hxx.

Referenced by createMultiDatastreamPorts(), and ElementaryNode().

◆ _setOfInputDataStreamPort

std::list<InputDataStreamPort *> YACS::ENGINE::ElementaryNode::_setOfInputDataStreamPort

protected

Definition at line 49 of file ElementaryNode.hxx.

Referenced by createMultiDatastreamPorts(), YACS::ENGINE::DSToDFForLoop::DSToDFForLoop(), edAddInputDataStreamPort(), edDisconnectAllLinksWithMe(), edRemovePort(), ElementaryNode(), ensureLoading(), getInputDataStreamPort(), YACS::ENGINE::DSToDFForLoop::getInputDataStreamPort(), and ~ElementaryNode().

◆ _setOfInputPort

std::list<InputPort *> YACS::ENGINE::ElementaryNode::_setOfInputPort

protected

Definition at line 47 of file ElementaryNode.hxx.

Referenced by areAllInputPortsValid(), checkBasicConsistency(), YACS::ENGINE::OutNode::checkBasicConsistency(), YACS::ENGINE::PresetNode::checkBasicConsistency(), YACS::ENGINE::StudyInNode::checkBasicConsistency(), YACS::ENGINE::StudyOutNode::checkBasicConsistency(), YACS::ENGINE::CppNode::cloneNode(), YACS::ENGINE::PythonNode::cloneNode(), YACS::ENGINE::PyFuncNode::cloneNode(), YACS::ENGINE::SalomePythonNode::cloneNode(), YACS::ENGINE::DFToDSForLoop::DFToDSForLoop(), YACS::ENGINE::OutNode::dump(), edAddInputPort(), edDisconnectAllLinksWithMe(), edOrderInputPorts(), edRemovePort(), ElementaryNode(), YACS::ENGINE::CORBANode::execute(), YACS::ENGINE::SalomeNode::execute(), YACS::ENGINE::CppNode::execute(), YACS::ENGINE::DistributedPythonNode::execute(), YACS::ENGINE::SalomePythonNode::execute(), YACS::ENGINE::StudyOutNode::execute(), YACS::ENGINE::XmlNode::execute(), YACS::ENGINE::PythonNode::executeLocal(), YACS::ENGINE::PyFuncNode::executeLocal(), YACS::ENGINE::PythonNode::executeRemote(), YACS::ENGINE::PyFuncNode::executeRemote(), getInputPort(), YACS::ENGINE::DFToDSForLoop::getInputPort(), getNumberOfInputPorts(), initCommonPartWithoutStateManagement(), YACS::ENGINE::PythonNode::squeezeMemory(), YACS::ENGINE::PythonNode::squeezeMemoryRemote(), and ~ElementaryNode().

◆ _setOfOutputDataStreamPort

std::list<OutputDataStreamPort *> YACS::ENGINE::ElementaryNode::_setOfOutputDataStreamPort

protected

Definition at line 50 of file ElementaryNode.hxx.

Referenced by createMultiDatastreamPorts(), YACS::ENGINE::DFToDSForLoop::DFToDSForLoop(), edAddOutputDataStreamPort(), edDisconnectAllLinksWithMe(), edRemovePort(), ElementaryNode(), ensureLoading(), getCoupledNodes(), getOutputDataStreamPort(), YACS::ENGINE::DFToDSForLoop::getOutputDataStreamPort(), and ~ElementaryNode().

◆ _setOfOutputPort

std::list<OutputPort *> YACS::ENGINE::ElementaryNode::_setOfOutputPort

protected

Definition at line 48 of file ElementaryNode.hxx.

◆ _weight

ComplexWeight YACS::ENGINE::ElementaryNode::_weight

protected

Definition at line 51 of file ElementaryNode.hxx.

Referenced by ElementaryNode(), and setWeight().

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

src/engine/ElementaryNode.hxx
src/engine/ElementaryNode.cxx

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ElementaryNode() [1/2]

◆ ElementaryNode() [2/2]

◆ ~ElementaryNode()

Member Function Documentation

◆ aborted()

◆ accept()

◆ addDatastreamPortToInitMultiService()

◆ areAllInputPortsValid()

◆ begin()

◆ checkBasicConsistency()

◆ connected()

◆ connectService()

◆ createInputDataStreamPort()

◆ createInputPort()

◆ createMultiDatastreamPorts()

◆ createOutputDataStreamPort()

◆ createOutputPort()

◆ disconnectService()

◆ edAddInputDataStreamPort()

◆ edAddInputPort()

◆ edAddOutputDataStreamPort()

◆ edAddOutputPort()

◆ edAddPort()

◆ edCheckAddPort()

◆ edDisconnectAllLinksWithMe()

◆ edOrderInputPorts()

◆ edOrderOutputPorts()

◆ edRemovePort()

◆ edRemovePortTypedFromSet()

◆ edUpdateState()

◆ ensureLoading()

◆ exUpdateState()

◆ finished()

◆ getAllInPortsComingFromOutsideOfCurrentScope()

◆ getAllOutPortsLeavingCurrentScope()

◆ getChildByName()

◆ getComponent() [1/2]

◆ getComponent() [2/2]

◆ getContainer()

◆ getCoupledNodes()

◆ getCoupledTasks()

◆ getDynClonerIfExists()

◆ getErrorDetails()

◆ getInPortName()

◆ getInputDataStreamPort()

◆ getInputPort()

◆ getLocalInputPorts()

◆ getLocalOutputPorts()

◆ getMaxLevelOfParallelism()

◆ getNumberOfInputPorts()

◆ getNumberOfOutputPorts()

◆ getOutPortName()

◆ getOutputDataStreamPort()

◆ getOutputPort()

◆ getPort()

◆ getProgressWeight()

◆ getReadyTasks()

◆ getRecursiveConstituents()

◆ getSetOfInputDataStreamPort()

◆ getSetOfInputPort()

◆ getSetOfLinksComingInCurrentScope()

◆ getSetOfLinksLeavingCurrentScope()

◆ getSetOfOutputDataStreamPort()

◆ getSetOfOutputPort()

◆ getState()

◆ getWeight()

◆ getWeightRegardingDPL()

◆ init()

◆ initCommonPartWithoutStateManagement()

◆ initService()

◆ isDeployable()

◆ isPortNameAlreadyExist()