YACS::HMI::SubjectComposedNode Class Reference

#include <guiObservers.hxx>

Inheritance diagram for YACS::HMI::SubjectComposedNode:

Collaboration diagram for YACS::HMI::SubjectComposedNode:

Public Member Functions
	SubjectComposedNode (YACS::ENGINE::ComposedNode *composedNode, Subject *parent)
virtual	~SubjectComposedNode ()
virtual SubjectNode *	addNode (YACS::ENGINE::Catalog *catalog, std::string compo, std::string type, std::string name, bool newCompoInst)
virtual SubjectNode *	getChild (YACS::ENGINE::Node *node=0) const
virtual void	loadChildren ()
virtual void	loadLinks ()
virtual void	completeChildrenSubjectList (SubjectNode *son)
SubjectNode *	addSubjectNode (YACS::ENGINE::Node *node, std::string name="", YACS::ENGINE::Catalog *catalog=0, std::string compo="", std::string type="")
SubjectLink *	addSubjectLink (SubjectNode *sno, SubjectDataPort *spo, SubjectNode *sni, SubjectDataPort *spi)
SubjectControlLink *	addSubjectControlLink (SubjectNode *sno, SubjectNode *sni)
virtual void	removeLink (SubjectLink *link)
virtual void	removeControlLink (SubjectControlLink *link)
virtual void	removeExternalControlLinks ()
virtual void	houseKeepingAfterCutPaste (bool isCut, SubjectNode *son)
virtual bool	hasValue ()
virtual std::string	getValue ()
virtual void	clean (Command *command=0)
void	localclean (Command *command=0)
Public Member Functions inherited from YACS::HMI::SubjectNode
	SubjectNode (YACS::ENGINE::Node *node, Subject *parent)
virtual	~SubjectNode ()
virtual bool	setProperties (std::map< std::string, std::string > properties)
virtual std::map< std::string, std::string >	getProperties ()
virtual bool	reparent (Subject *parent)
virtual bool	copy (Subject *parent)
virtual std::string	getName ()
virtual bool	setName (std::string name)
virtual YACS::ENGINE::Node *	getNode ()
void	registerUndoDestroy ()
SubjectControlLink *	addSubjectControlLink (SubjectControlLink *sub)
void	removeSubjectControlLink (SubjectControlLink *sub)
std::list< SubjectLink * >	getSubjectLinks () const
std::list< SubjectControlLink * >	getSubjectControlLinks () const
std::list< SubjectInputPort * >	getSubjectInputPorts () const
std::list< SubjectOutputPort * >	getSubjectOutputPorts () const
std::list< SubjectInputDataStreamPort * >	getSubjectInputDataStreamPorts () const
std::list< SubjectOutputDataStreamPort * >	getSubjectOutputDataStreamPorts () const
void	localclean (Command *command=0)
virtual void	update (GuiEvent event, int type, Subject *son)
virtual void	recursiveUpdate (GuiEvent event, int type, Subject *son)
virtual void	removeExternalLinks ()
virtual void	saveLinks ()
virtual void	restoreLinks ()
virtual bool	putInComposedNode (std::string name, std::string type, bool toSaveRestoreLinks=true)
virtual int	isValid ()
void	setExecState (int execState)
Public Member Functions inherited from YACS::HMI::Subject
	Subject (Subject *parent=0)
virtual	~Subject ()
virtual void	attach (GuiObserver *obs)
virtual void	detach (GuiObserver *obs)
virtual void	select (bool isSelected)
virtual std::vector< std::string >	knownProperties ()
virtual Subject *	getParent ()
virtual void	setParent (Subject *son)
virtual bool	destroy (Subject *son)
	From user action in Ihm, destroy an object. More...
virtual void	addSubjectReference (Subject *ref)
void	localclean (Command *command=0)
void	registerUndoDestroy ()
void	askRegisterUndoDestroy ()
bool	isDestructible ()
virtual TypeOfElem	getType ()
virtual void	setProgress (std::string newProgress)
virtual std::string	getProgress ()
Public Member Functions inherited from YACS::ENGINE::Observer
virtual void	notifyObserver2 (Node *object, const std::string &event, void *something)
virtual void	notifyObserverFromClone (Node *originalInstance, const std::string &event, Node *clonedInstanceGeneratingEvent)
virtual	~Observer ()

Static Public Member Functions
static SubjectComposedNode *	getLowestCommonAncestor (SubjectNode *snode1, SubjectNode *snode2)
	Retrieves the lowest common ancestor of 2 nodes. More...
Static Public Member Functions inherited from YACS::HMI::SubjectNode
static bool	tryCreateLink (SubjectNode *subOutNode, SubjectNode *subInNode)
Static Public Member Functions inherited from YACS::HMI::Subject
static void	erase (Subject *sub, Command *command=0, bool post=false)

Protected Member Functions
virtual SubjectNode *	createNode (YACS::ENGINE::Catalog *catalog, std::string compo, std::string type, std::string name, bool newCompoInst, int swCase=0)
Protected Member Functions inherited from YACS::HMI::SubjectNode
virtual SubjectInputPort *	addSubjectInputPort (YACS::ENGINE::InputPort *port, std::string name="")
virtual SubjectOutputPort *	addSubjectOutputPort (YACS::ENGINE::OutputPort *port, std::string name="")
virtual SubjectInputDataStreamPort *	addSubjectIDSPort (YACS::ENGINE::InputDataStreamPort *port, std::string name="")
virtual SubjectOutputDataStreamPort *	addSubjectODSPort (YACS::ENGINE::OutputDataStreamPort *port, std::string name="")
virtual void	notifyObserver (YACS::ENGINE::Node *object, const std::string &event)

Protected Attributes
YACS::ENGINE::ComposedNode *	_composedNode
Protected Attributes inherited from YACS::HMI::SubjectNode
YACS::ENGINE::Node *	_node
std::list< SubjectInputPort * >	_listSubjectInputPort
std::list< SubjectOutputPort * >	_listSubjectOutputPort
std::list< SubjectInputDataStreamPort * >	_listSubjectIDSPort
std::list< SubjectOutputDataStreamPort * >	_listSubjectODSPort
std::list< SubjectLink * >	_listSubjectLink
std::list< SubjectControlLink * >	_listSubjectControlLink
int	_execState
std::list< YACS::ENGINE::OutGate * >	loutgate
std::list< YACS::ENGINE::InGate * >	singate
std::vector< std::pair< YACS::ENGINE::OutPort *, YACS::ENGINE::InPort * > >	dataLinks
std::vector< std::pair< YACS::ENGINE::OutPort *, YACS::ENGINE::InPort * > >	dataflowLinks
Protected Attributes inherited from YACS::HMI::Subject
std::set< GuiObserver * >	_setObs
Subject *	_parent
bool	_destructible
bool	_askRegisterUndo
std::string	_progress

Detailed Description

Definition at line 348 of file guiObservers.hxx.

Constructor & Destructor Documentation

SubjectComposedNode()

SubjectComposedNode::SubjectComposedNode	(	YACS::ENGINE::ComposedNode *	composedNode,
		Subject *	parent
	)

Definition at line 1316 of file guiObservers.cxx.

  : SubjectNode(composedNode, parent), _composedNode(composedNode)
{
}

~SubjectComposedNode()

SubjectComposedNode::~SubjectComposedNode ( )

virtual

all generic destruction is done in generic class SubjectNode

Definition at line 1325 of file guiObservers.cxx.

{
  DEBTRACE("SubjectComposedNode::~SubjectComposedNode " << getName());
}

References DEBTRACE, and YACS::HMI::SubjectNode::getName().

Member Function Documentation

addNode()

SubjectNode * SubjectComposedNode::addNode ( YACS::ENGINE::Catalog *  catalog, std::string  compo, std::string  type, std::string  name, bool  newCompoInst  )

virtual

Reimplemented in YACS::HMI::SubjectDynParaLoop, YACS::HMI::SubjectWhileLoop, YACS::HMI::SubjectForLoop, and YACS::HMI::SubjectBloc.

Definition at line 1346 of file guiObservers.cxx.

{
  DEBTRACE("SubjectComposedNode::addNode("<<catalog<<","<<compo<<","<<type<<","<<name<<")");
  SubjectNode* body = 0;
  GuiContext::getCurrent()->_lastErrorMessage = "YACS Internal Error: SubjectComposedNode::addNode"; 
  return body;
}

References YACS::HMI::GuiContext::_lastErrorMessage, DEBTRACE, and YACS::HMI::GuiContext::getCurrent().

Referenced by YACS::HMI::GuiEditor::_createNode(), and gui.GraphViewer.GraphViewer::popup().

addSubjectControlLink()

SubjectControlLink * SubjectComposedNode::addSubjectControlLink	(	SubjectNode *	sno,
		SubjectNode *	sni
	)

Definition at line 1551 of file guiObservers.cxx.

{
  Node *outn = sno->getNode();
  Node *inn = sni->getNode();
  pair<Node*,Node*> keyLink(outn,inn);
  //Don't create a new subject if it already exists
  if(GuiContext::getCurrent()->_mapOfSubjectControlLink.count(keyLink)!=0)
    return GuiContext::getCurrent()->_mapOfSubjectControlLink[keyLink];
 
  SubjectControlLink *son = new SubjectControlLink(sno, sni, this);
  GuiContext::getCurrent()->_mapOfSubjectControlLink[keyLink] = son;
  _listSubjectControlLink.push_back(son);
  sno->addSubjectControlLink(son);
  sni->addSubjectControlLink(son);
  update(ADDCONTROLLINK, CONTROLLINK, son);
  DEBTRACE("addSubjectControlLink: " << getName() << " " << son->getName());
  return son;
}

References YACS::HMI::SubjectNode::_listSubjectControlLink, YACS::HMI::GuiContext::_mapOfSubjectControlLink, YACS::HMI::ADDCONTROLLINK, YACS::HMI::SubjectNode::addSubjectControlLink(), YACS::HMI::CONTROLLINK, DEBTRACE, YACS::HMI::GuiContext::getCurrent(), YACS::HMI::SubjectNode::getName(), YACS::HMI::SubjectControlLink::getName(), YACS::HMI::SubjectNode::getNode(), and YACS::HMI::SubjectNode::update().

Referenced by loadLinks(), YACS::HMI::CommandAddLink::localExecute(), YACS::HMI::CommandAddControlLink::localExecute(), and YACS::HMI::SubjectNode::restoreLinks().

addSubjectLink()

SubjectLink * SubjectComposedNode::addSubjectLink	(	SubjectNode *	sno,
		SubjectDataPort *	spo,
		SubjectNode *	sni,
		SubjectDataPort *	spi
	)

Definition at line 1508 of file guiObservers.cxx.

{
  DEBTRACE("SubjectComposedNode::addSubjectLink");
  OutPort *outp = dynamic_cast<OutPort*>(spo->getPort());
  InPort *inp = dynamic_cast<InPort*>(spi->getPort());
  pair<OutPort*,InPort*> keyLink(outp,inp);
  //Don't create a new subject if it already exists
  if(GuiContext::getCurrent()->_mapOfSubjectLink.count(keyLink)!=0)
    return GuiContext::getCurrent()->_mapOfSubjectLink[keyLink];
 
  SubjectLink *son = new SubjectLink(sno, spo, sni, spi, this);
  GuiContext::getCurrent()->_mapOfSubjectLink[keyLink] = son;
  _listSubjectLink.push_back(son);
  spo->addSubjectLink(son);
  spi->addSubjectLink(son);
  update(ADDLINK, DATALINK, son);
  spi->update(UPDATE, DATALINK, spo);
  spo->update(UPDATE, DATALINK, spi);
  DEBTRACE("addSubjectLink: " << getName() << " " << son->getName());
  return son;
}

References YACS::HMI::SubjectNode::_listSubjectLink, YACS::HMI::GuiContext::_mapOfSubjectLink, YACS::HMI::ADDLINK, YACS::HMI::SubjectDataPort::addSubjectLink(), YACS::HMI::DATALINK, DEBTRACE, YACS::HMI::GuiContext::getCurrent(), YACS::HMI::SubjectNode::getName(), YACS::HMI::SubjectLink::getName(), YACS::HMI::SubjectDataPort::getPort(), YACS::HMI::UPDATE, YACS::HMI::Subject::update(), and YACS::HMI::SubjectNode::update().

Referenced by loadLinks(), YACS::HMI::CommandAddLink::localExecute(), and YACS::HMI::SubjectNode::restoreLinks().

addSubjectNode()

SubjectNode * SubjectComposedNode::addSubjectNode	(	YACS::ENGINE::Node *	node,
		std::string	name = "",
		YACS::ENGINE::Catalog *	catalog = 0,
		std::string	compo = "",
		std::string	type = ""
	)

Definition at line 1385 of file guiObservers.cxx.

{
  string theName = name;
  if (name.empty()) theName =node->getName();
  DEBTRACE("SubjectComposedNode::addSubjectNode "<< theName);
  TypeOfElem ntyp = ProcInvoc::getTypeOfNode(node);
  DEBTRACE("TypeOfNode: " << ntyp);
  SubjectNode *son = 0;
  switch(ntyp)
    {
    case BLOC:
      son = new SubjectBloc(dynamic_cast<YACS::ENGINE::Bloc*>(node), this);
      break;
    case PYTHONNODE:
      son = new SubjectPythonNode(dynamic_cast<YACS::ENGINE::PythonNode*>(node), this);
      break;
    case PYFUNCNODE:
      son = new SubjectPyFuncNode(dynamic_cast<YACS::ENGINE::PyFuncNode*>(node), this);
      break;
    case CORBANODE:
      son = new SubjectCORBANode(dynamic_cast<YACS::ENGINE::CORBANode*>(node), this);
      break;
    case CPPNODE:
      son = new SubjectCppNode(dynamic_cast<YACS::ENGINE::CppNode*>(node), this);
      break;
    case SALOMENODE:
      son = new SubjectSalomeNode(dynamic_cast<YACS::ENGINE::SalomeNode*>(node), this);
      break;
    case SALOMEPYTHONNODE:
      son = new SubjectSalomePythonNode(dynamic_cast<YACS::ENGINE::SalomePythonNode*>(node), this);
      break;
    case XMLNODE:
      son = new SubjectXmlNode(dynamic_cast<YACS::ENGINE::XmlNode*>(node), this);
      break;
    case SPLITTERNODE:
      son = new SubjectSplitterNode(dynamic_cast<YACS::ENGINE::SplitterNode*>(node), this);
      break;
    case PRESETNODE:
      son = new SubjectPresetNode(dynamic_cast<YACS::ENGINE::PresetNode*>(node), this);
      break;
    case OUTNODE:
      son = new SubjectOutNode(dynamic_cast<YACS::ENGINE::OutNode*>(node), this);
      break;
    case STUDYINNODE:
      son = new SubjectStudyInNode(dynamic_cast<YACS::ENGINE::StudyInNode*>(node), this);
      break;
    case STUDYOUTNODE:
      son = new SubjectStudyOutNode(dynamic_cast<YACS::ENGINE::StudyOutNode*>(node), this);
      break;
    case FORLOOP:
      son = new SubjectForLoop(dynamic_cast<YACS::ENGINE::ForLoop*>(node), this);
      break;
    case WHILELOOP:
      son = new SubjectWhileLoop(dynamic_cast<YACS::ENGINE::WhileLoop*>(node), this);
      break;
    case SWITCH:
      son = new SubjectSwitch(dynamic_cast<YACS::ENGINE::Switch*>(node), this);
      break;
    case FOREACHLOOP:
      son = new SubjectForEachLoop(dynamic_cast<YACS::ENGINE::ForEachLoopGen*>(node), this);
      break;
    case OPTIMIZERLOOP:
      son = new SubjectOptimizerLoop(dynamic_cast<YACS::ENGINE::OptimizerLoop*>(node), this);
      break;
    default:
      throw YACS::Exception("Not implemented");
      //YASSERT(0);
    }
  YASSERT(son);
  GuiContext::getCurrent()->_mapOfSubjectNode[static_cast<Node*>(node)] = son;
  GuiContext::getCurrent()->_mapOfExecSubjectNode[node->getNumId()] = son;
  if (!name.empty()) son->setName(name);
  completeChildrenSubjectList(son);
  update(ADD, ntyp ,son);
  if (SubjectServiceNode *service = dynamic_cast<SubjectServiceNode*>(son))
    if (catalog && !compo.empty() && !type.empty()) // --- clone from catalog: set component
      service->setComponentFromCatalog(catalog,compo,type);
    else
      service->setComponent();
  return son;
}

References YACS::HMI::GuiContext::_mapOfExecSubjectNode, YACS::HMI::GuiContext::_mapOfSubjectNode, YACS::HMI::ADD, YACS::HMI::BLOC, completeChildrenSubjectList(), YACS::HMI::CORBANODE, YACS::HMI::CPPNODE, DEBTRACE, YACS::HMI::FOREACHLOOP, YACS::HMI::FORLOOP, YACS::HMI::GuiContext::getCurrent(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Node::getNumId(), YACS::HMI::ProcInvoc::getTypeOfNode(), YACS::HMI::OPTIMIZERLOOP, YACS::HMI::OUTNODE, YACS::HMI::PRESETNODE, YACS::HMI::PYFUNCNODE, YACS::HMI::PYTHONNODE, YACS::HMI::SALOMENODE, YACS::HMI::SALOMEPYTHONNODE, YACS::HMI::SubjectNode::setName(), YACS::HMI::SPLITTERNODE, YACS::HMI::STUDYINNODE, YACS::HMI::STUDYOUTNODE, YACS::HMI::SWITCH, YACS::HMI::SubjectNode::update(), YACS::HMI::WHILELOOP, YACS::HMI::XMLNODE, and YASSERT.

Referenced by loadChildren(), YACS::HMI::CommandAddNodeFromCatalog::localExecute(), YACS::HMI::CommandPutInComposedNode::localExecute(), and YACS::HMI::CommandCopyNode::localExecute().

clean()

void SubjectComposedNode::clean ( Command *  command = 0 )

virtual

Clean process prior to delete is redefined in derived classes: a local clean treatment relative to the derived class, then a call to the parent class clean method.

Reimplemented from YACS::HMI::SubjectNode.

Reimplemented in YACS::HMI::SubjectDynParaLoop, YACS::HMI::SubjectOptimizerLoop, YACS::HMI::SubjectForEachLoop, YACS::HMI::SubjectSwitch, YACS::HMI::SubjectWhileLoop, YACS::HMI::SubjectForLoop, YACS::HMI::SubjectProc, and YACS::HMI::SubjectBloc.

Definition at line 1330 of file guiObservers.cxx.

{
  if (_askRegisterUndo)
    {
      _askRegisterUndo = false;
      registerUndoDestroy();
    }
  localclean(command);
  SubjectNode::clean(command);
}

References YACS::HMI::Subject::_askRegisterUndo, YACS::HMI::SubjectNode::clean(), localclean(), and YACS::HMI::SubjectNode::registerUndoDestroy().

Referenced by YACS::HMI::SubjectBloc::clean(), YACS::HMI::SubjectForLoop::clean(), YACS::HMI::SubjectWhileLoop::clean(), YACS::HMI::SubjectSwitch::clean(), and YACS::HMI::SubjectDynParaLoop::clean().

completeChildrenSubjectList()

void SubjectComposedNode::completeChildrenSubjectList ( SubjectNode *  son )

virtual

Reimplemented in YACS::HMI::SubjectForEachLoop, YACS::HMI::SubjectDynParaLoop, YACS::HMI::SubjectSwitch, YACS::HMI::SubjectWhileLoop, YACS::HMI::SubjectForLoop, and YACS::HMI::SubjectBloc.

Definition at line 1471 of file guiObservers.cxx.

{
}

Referenced by addSubjectNode().

createNode()

SubjectNode * SubjectComposedNode::createNode ( YACS::ENGINE::Catalog *  catalog, std::string  compo, std::string  type, std::string  name, bool  newCompoInst, int  swCase = 0  )

protectedvirtual

Definition at line 1358 of file guiObservers.cxx.

{
  Proc *proc = GuiContext::getCurrent()->getProc();
  string position = "";
  if (proc != dynamic_cast<Proc*>(_node)) position = proc->getChildName(_node);
  CommandAddNodeFromCatalog *command = new CommandAddNodeFromCatalog(catalog,
                                                                     compo,
                                                                     type,
                                                                     position,
                                                                     name,
                                                                     newCompoInst,
                                                                     swCase);
  if (command->execute())
    {
      GuiContext::getCurrent()->getInvoc()->add(command);
      Node * node = command->getNode();
      return command->getSubjectNode();
    }
  else delete command;
  return 0;
}

References YACS::HMI::SubjectNode::_node, YACS::HMI::Invocator::add(), YACS::HMI::Command::execute(), YACS::ENGINE::ComposedNode::getChildName(), YACS::HMI::GuiContext::getCurrent(), YACS::HMI::GuiContext::getInvoc(), YACS::HMI::CommandAddNodeFromCatalog::getNode(), YACS::HMI::GuiContext::getProc(), and YACS::HMI::CommandAddNodeFromCatalog::getSubjectNode().

Referenced by YACS::HMI::SubjectBloc::addNode(), YACS::HMI::SubjectForLoop::addNode(), YACS::HMI::SubjectWhileLoop::addNode(), YACS::HMI::SubjectDynParaLoop::addNode(), and YACS::HMI::SubjectSwitch::addNode().

getChild()

virtual SubjectNode* YACS::HMI::SubjectComposedNode::getChild ( YACS::ENGINE::Node *  node = 0 ) const

inlinevirtual

Reimplemented in YACS::HMI::SubjectDynParaLoop, YACS::HMI::SubjectSwitch, YACS::HMI::SubjectWhileLoop, YACS::HMI::SubjectForLoop, and YACS::HMI::SubjectBloc.

Definition at line 358 of file guiObservers.hxx.

{ return 0; }

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

getLowestCommonAncestor()

SubjectComposedNode * SubjectComposedNode::getLowestCommonAncestor ( SubjectNode *  snode1, SubjectNode *  snode2  )

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 1681 of file guiObservers.cxx.

{
  Node* node1 = snode1->getNode();
  Node* node2 = snode2->getNode();
 
  ComposedNode *node = ComposedNode::getLowestCommonAncestor(node1->getFather(), node2->getFather());
  SubjectComposedNode* snode = dynamic_cast<SubjectComposedNode*>( GuiContext::getCurrent()->_mapOfSubjectNode[node] );
  return snode;
}

References YACS::HMI::GuiContext::_mapOfSubjectNode, YACS::HMI::GuiContext::getCurrent(), YACS::HMI::SubjectNode::getNode(), testCppPluginInvokation::node1, and testCppPluginInvokation::node2.

getValue()

std::string SubjectComposedNode::getValue ( )

virtual

used in derived classes using a counter, a selector, or a condition: ForLoop, ForEachLoop, Switch, WhileLoop.

Reimplemented in YACS::HMI::SubjectDynParaLoop, YACS::HMI::SubjectSwitch, YACS::HMI::SubjectWhileLoop, and YACS::HMI::SubjectForLoop.

Definition at line 1702 of file guiObservers.cxx.

{
  return "";
}

Referenced by YACS::HMI::SchemaComposedNodeItem::SchemaComposedNodeItem(), YACS::HMI::EditionForEachLoop::update(), YACS::HMI::EditionLoop::update(), YACS::HMI::EditionOptimizerLoop::update(), YACS::HMI::EditionSwitch::update(), YACS::HMI::EditionWhile::update(), and YACS::HMI::SchemaComposedNodeItem::update().

hasValue()

bool SubjectComposedNode::hasValue ( )

virtual

used in derived classes using a counter, a selector, or a condition: ForLoop, ForEachLoop, Switch, WhileLoop.

Reimplemented in YACS::HMI::SubjectDynParaLoop, YACS::HMI::SubjectSwitch, YACS::HMI::SubjectWhileLoop, and YACS::HMI::SubjectForLoop.

Definition at line 1694 of file guiObservers.cxx.

{
  return false;
}

Referenced by YACS::HMI::SchemaComposedNodeItem::SchemaComposedNodeItem(), and YACS::HMI::SchemaComposedNodeItem::update().

houseKeepingAfterCutPaste()

void SubjectComposedNode::houseKeepingAfterCutPaste ( bool  isCut, SubjectNode *  son  )

virtual

Reimplemented in YACS::HMI::SubjectDynParaLoop, YACS::HMI::SubjectSwitch, YACS::HMI::SubjectWhileLoop, YACS::HMI::SubjectForLoop, and YACS::HMI::SubjectBloc.

Definition at line 1607 of file guiObservers.cxx.

{
}

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

loadChildren()

void SubjectComposedNode::loadChildren ( )

virtual

Reimplemented from YACS::HMI::Subject.

Definition at line 1475 of file guiObservers.cxx.

{
  list<Node *> setOfNode= _composedNode->edGetDirectDescendants();
  if (ForEachLoopGen *feloop = dynamic_cast<ForEachLoopGen*>(_composedNode))
    {
      Node *node2Insert=feloop->getChildByName(ForEachLoopGen::NAME_OF_SPLITTERNODE);
      if(find(setOfNode.begin(),setOfNode.end(),node2Insert)==setOfNode.end())
        setOfNode.push_back(node2Insert);
    }
  for(list<Node *>::iterator iter=setOfNode.begin();iter!=setOfNode.end();iter++)
    {
      try
        {
          SubjectNode * son = addSubjectNode(*iter);
          son->loadChildren();
        }
      catch(YACS::Exception& ex)
        {
          std::cerr << "Unknown type of node" << std::endl;
        }
    }
  list<InputPort*>  listInputPorts  = _composedNode->getLocalInputPorts();
  list<OutputPort*> listOutputPorts = _composedNode->getLocalOutputPorts();
  list<InputDataStreamPort*>  listIDSPorts = _composedNode->getSetOfInputDataStreamPort();
  list<OutputDataStreamPort*> listODSPorts = _composedNode->getSetOfOutputDataStreamPort();
  list<InputPort*>::const_iterator iti;
  for (iti = listInputPorts.begin(); iti != listInputPorts.end(); ++iti)
    addSubjectInputPort(*iti);
  list<OutputPort*>::const_iterator ito;
  for (ito = listOutputPorts.begin(); ito != listOutputPorts.end(); ++ito)
    addSubjectOutputPort(*ito);
}

References _composedNode, YACS::HMI::SubjectNode::addSubjectInputPort(), addSubjectNode(), YACS::HMI::SubjectNode::addSubjectOutputPort(), YACS::ENGINE::ComposedNode::edGetDirectDescendants(), testCppPluginInvokation::ex, YACS::ENGINE::Node::getChildByName(), YACS::ENGINE::ComposedNode::getLocalInputPorts(), YACS::ENGINE::ComposedNode::getLocalOutputPorts(), YACS::ENGINE::ComposedNode::getSetOfInputDataStreamPort(), YACS::ENGINE::ComposedNode::getSetOfOutputDataStreamPort(), and YACS::HMI::Subject::loadChildren().

Referenced by YACS::HMI::SubjectProc::loadProc().

loadLinks()

void SubjectComposedNode::loadLinks ( )

virtual

loadLinks is used when an existing scheme has been loaded in memory, to create gui representation. Gui representation of links is done after node representation (loadChildren). Proc is explored recursively to find the composedNodes and create the corresponding links representation, from bottom to top. For each composedNode, data links representation are created first and stored in a map to avoid double representation. Then control links representation are created.

Reimplemented from YACS::HMI::Subject.

Definition at line 1619 of file guiObservers.cxx.

{
  list<Node *> setOfNode= _composedNode->edGetDirectDescendants();
  for(list<Node *>::iterator iter=setOfNode.begin();iter!=setOfNode.end();iter++)
    {
      ComposedNode *cnSon = dynamic_cast<ComposedNode*>(*iter);
      if (cnSon)
        {
          SubjectNode *subSon = GuiContext::getCurrent()->_mapOfSubjectNode[static_cast<Node*>(*iter)];
          YASSERT(subSon);
          SubjectComposedNode *subCnSon = dynamic_cast<SubjectComposedNode*>(subSon);
          YASSERT(subCnSon);
          subCnSon->loadLinks();
        }
    }
 
  std::vector<std::pair<OutPort*,InPort*> > setOfLinks = _composedNode->getSetOfInternalLinks();
  std::vector<std::pair<OutPort*,InPort*> >::iterator itp;
  for (itp = setOfLinks.begin(); itp != setOfLinks.end(); ++itp)
    if (!GuiContext::getCurrent()->_mapOfSubjectLink.count(*itp))
      {
        OutPort *outp = (*itp).first;
        InPort *inp = (*itp).second;
        Node *outn = outp->getNode();
        Node *inn = inp->getNode();
        DEBTRACE(outn->getName()<<"."<<outp->getName()<<"->"<<inn->getName()<<"."<<inp->getName());
        SubjectNode *sno = GuiContext::getCurrent()->_mapOfSubjectNode[static_cast<Node*>(outn)];
        SubjectNode *sni = GuiContext::getCurrent()->_mapOfSubjectNode[static_cast<Node*>(inn)];
        SubjectDataPort *spo = GuiContext::getCurrent()->_mapOfSubjectDataPort[static_cast<DataPort*>(outp)];
        SubjectDataPort *spi = GuiContext::getCurrent()->_mapOfSubjectDataPort[static_cast<DataPort*>(inp)];
        addSubjectLink(sno,spo,sni,spi);
      }
 
  std::list<Node*> setOfNodes = _composedNode->edGetDirectDescendants();
  std::list<Node*>::const_iterator itn;
  for(itn = setOfNodes.begin(); itn != setOfNodes.end(); ++itn)
    {
      SubjectNode* sno = GuiContext::getCurrent()->_mapOfSubjectNode[*itn];
      OutGate* outgate = (*itn)->getOutGate();
      std::list<InGate*> setIngate = outgate->edSetInGate();
      std::list<InGate*>::const_iterator itg;
      for(itg = setIngate.begin(); itg != setIngate.end(); ++itg)
        {
          Node* inNode = (*itg)->getNode();
          SubjectNode* sni = GuiContext::getCurrent()->_mapOfSubjectNode[inNode];
          if(sno && sni)
            addSubjectControlLink(sno,sni);
        }
    }
}

References _composedNode, YACS::HMI::GuiContext::_mapOfSubjectDataPort, YACS::HMI::GuiContext::_mapOfSubjectNode, addSubjectControlLink(), addSubjectLink(), DEBTRACE, YACS::ENGINE::ComposedNode::edGetDirectDescendants(), YACS::ENGINE::OutGate::edSetInGate(), YACS::HMI::GuiContext::getCurrent(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Port::getNode(), YACS::ENGINE::ComposedNode::getSetOfInternalLinks(), loadLinks(), and YASSERT.

Referenced by loadLinks(), and YACS::HMI::SubjectProc::loadProc().

localclean()

void SubjectComposedNode::localclean

(

Command *

command = 0

)

Definition at line 1341 of file guiObservers.cxx.

{
  DEBTRACE("SubjectComposedNode::localClean ");
}

References DEBTRACE.

Referenced by clean().

removeControlLink()

void SubjectComposedNode::removeControlLink ( SubjectControlLink *  link )

virtual

Definition at line 1571 of file guiObservers.cxx.

{
  DEBTRACE("removeSubjectControlLink: " << getName());
 
  Node *outn = link->getSubjectOutNode()->getNode();
  Node *inn = link->getSubjectInNode()->getNode();
  pair<Node*,Node*> keyLink(outn,inn);
  if (GuiContext::getCurrent()->_mapOfSubjectControlLink.count(keyLink))
    {
      DEBTRACE(outn->getName() << " " << inn->getName());
      GuiContext::getCurrent()->_mapOfSubjectControlLink.erase(keyLink);
    }
 
  link->getSubjectOutNode()->removeSubjectControlLink(link);
  link->getSubjectInNode()->removeSubjectControlLink(link);
  _listSubjectControlLink.remove(link);
}

References YACS::HMI::SubjectNode::_listSubjectControlLink, YACS::HMI::GuiContext::_mapOfSubjectControlLink, DEBTRACE, YACS::HMI::GuiContext::getCurrent(), YACS::HMI::SubjectNode::getName(), YACS::ENGINE::Node::getName(), YACS::HMI::SubjectNode::getNode(), YACS::HMI::SubjectControlLink::getSubjectInNode(), YACS::HMI::SubjectControlLink::getSubjectOutNode(), and YACS::HMI::SubjectNode::removeSubjectControlLink().

Referenced by YACS::HMI::SubjectControlLink::localclean().

removeExternalControlLinks()

void SubjectComposedNode::removeExternalControlLinks ( )

virtual

Reimplemented from YACS::HMI::SubjectNode.

Definition at line 1589 of file guiObservers.cxx.

{
  DEBTRACE("SubjectComposedNode::removeExternalControlLinks " << getName());
  list<SubjectControlLink*> cplcl = getSubjectControlLinks();
  list<SubjectControlLink*>::iterator its;
  ComposedNode *cnode = dynamic_cast<ComposedNode*>(getNode());
  for (its = cplcl.begin(); its != cplcl.end(); ++its)
    {
      bool inside = true;
      Node *nout = (*its)->getSubjectOutNode()->getNode();
      Node *nin = (*its)->getSubjectInNode()->getNode();
      inside = inside && cnode->isInMyDescendance(nout); // --- 0 if nout is outside
      inside = inside && cnode->isInMyDescendance(nin);  // --- 0 if nin is outside
      if (!inside)
        Subject::erase(*its);
    }
}   

References DEBTRACE, YACS::HMI::Subject::erase(), YACS::HMI::SubjectNode::getName(), YACS::HMI::SubjectNode::getNode(), YACS::HMI::SubjectNode::getSubjectControlLinks(), and YACS::ENGINE::ComposedNode::isInMyDescendance().

removeLink()

void SubjectComposedNode::removeLink ( SubjectLink *  link )

virtual

Definition at line 1533 of file guiObservers.cxx.

{
  DEBTRACE("removeLink: " << link->getName());
 
  OutPort *outp = dynamic_cast<OutPort*>(link->getSubjectOutPort()->getPort());
  InPort  *inp  = dynamic_cast<InPort*>(link->getSubjectInPort()->getPort());
  pair<OutPort*,InPort*> keyLink(outp,inp);
  if (GuiContext::getCurrent()->_mapOfSubjectLink.count(keyLink))
    {
      DEBTRACE(outp->getName() << " " << inp->getName());
      GuiContext::getCurrent()->_mapOfSubjectLink.erase(keyLink);
    }
 
  link->getSubjectOutPort()->removeSubjectLink(link);
  link->getSubjectInPort()->removeSubjectLink(link);
  _listSubjectLink.remove(link);
}

References YACS::HMI::SubjectNode::_listSubjectLink, YACS::HMI::GuiContext::_mapOfSubjectLink, DEBTRACE, YACS::HMI::GuiContext::getCurrent(), YACS::HMI::SubjectLink::getName(), YACS::ENGINE::DataPort::getName(), YACS::HMI::SubjectDataPort::getPort(), YACS::HMI::SubjectLink::getSubjectInPort(), YACS::HMI::SubjectLink::getSubjectOutPort(), and YACS::HMI::SubjectDataPort::removeSubjectLink().

Referenced by YACS::HMI::SubjectLink::localclean().

Member Data Documentation

_composedNode

YACS::ENGINE::ComposedNode* YACS::HMI::SubjectComposedNode::_composedNode

protected

Definition at line 389 of file guiObservers.hxx.

Referenced by loadChildren(), and loadLinks().

---

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

• src/hmi/guiObservers.hxx
• src/hmi/guiObservers.cxx