Version: 8.3.0
ElementaryNode.hxx
Go to the documentation of this file.
1 // Copyright (C) 2006-2016 CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 
20 #ifndef __ELEMENTARYNODE_HXX__
21 #define __ELEMENTARYNODE_HXX__
22 
23 #include "YACSlibEngineExport.hxx"
24 #include "Node.hxx"
25 #include "Task.hxx"
26 #include "define.hxx"
27 
28 #include <string>
29 #include <algorithm>
30 
31 namespace YACS
32 {
33  namespace ENGINE
34  {
35  class TypeCode;
36  class Port;
37  class InputPort;
38  class OutputPort;
39  class ComposedNode;
40  class InputDataStreamPort;
41  class OutputDataStreamPort;
42 
43  class YACSLIBENGINE_EXPORT ElementaryNode : public Node, public Task
44  {
45  friend class ComposedNode;
46  protected:
47  std::list<InputPort *> _setOfInputPort;
48  std::list<OutputPort *> _setOfOutputPort;
49  std::list<InputDataStreamPort *> _setOfInputDataStreamPort;
50  std::list<OutputDataStreamPort *> _setOfOutputDataStreamPort;
51 
52  // Management of multi property
53  bool _createDatastreamPorts;
54  bool _multi_port_node;
55  protected:
56  ElementaryNode(const std::string& name);
57  ElementaryNode(const ElementaryNode& other, ComposedNode *father);
58  void performDuplicationOfPlacement(const Node& other);
59  void performShallowDuplicationOfPlacement(const Node& other);
60  public:
61  virtual ~ElementaryNode();
62  void exUpdateState();
63  void init(bool start=true);
64  bool isDeployable() const;
65  ComponentInstance *getComponent();
66  const ComponentInstance *getComponent() const;
67  Container *getContainer();
68  YACS::StatesForNode getState() const;
69  void getReadyTasks(std::vector<Task *>& tasks);
70  void edRemovePort(Port *port) throw(Exception);
71  std::list<ElementaryNode *> getRecursiveConstituents() const;
72  std::list<ProgressWeight> getProgressWeight() const;
73  Node *getChildByName(const std::string& name) const throw(Exception);
74  virtual void checkBasicConsistency() const throw(Exception);
75  ComposedNode *getDynClonerIfExists(const ComposedNode *levelToStop) const;
76  int getNumberOfInputPorts() const;
77  int getNumberOfOutputPorts() const;
78  std::string getInPortName(const InPort *) const throw (Exception);
79  std::string getOutPortName(const OutPort *) const throw (Exception);
80  InputPort *getInputPort(const std::string& name) const throw(Exception);
81  OutputPort *getOutputPort(const std::string& name) const throw(Exception);
82  std::list<InputPort *> getSetOfInputPort() const { return _setOfInputPort; }
83  std::list<OutputPort *> getSetOfOutputPort() const { return _setOfOutputPort; }
84  std::list<InputPort *> getLocalInputPorts() const { return _setOfInputPort; }
85  std::list<OutputPort *> getLocalOutputPorts() const { return _setOfOutputPort; }
86  std::set<OutPort *> getAllOutPortsLeavingCurrentScope() const;
87  std::set<InPort *> getAllInPortsComingFromOutsideOfCurrentScope() const;
88  virtual std::vector< std::pair<OutPort *, InPort *> > getSetOfLinksLeavingCurrentScope() const;
89  virtual std::vector< std::pair<InPort *, OutPort *> > getSetOfLinksComingInCurrentScope() const;
90  std::list<InputDataStreamPort *> getSetOfInputDataStreamPort() const { return _setOfInputDataStreamPort; }
91  std::list<OutputDataStreamPort *> getSetOfOutputDataStreamPort() const { return _setOfOutputDataStreamPort; }
92  InputDataStreamPort *getInputDataStreamPort(const std::string& name) const throw(Exception);
93  OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const throw(Exception);
94  virtual InputPort *createInputPort(const std::string& inputPortName, TypeCode* type);
95  virtual OutputPort *createOutputPort(const std::string& outputPortName, TypeCode* type);
96  virtual InputDataStreamPort *createInputDataStreamPort(const std::string& inputPortDSName, TypeCode* type);
97  virtual OutputDataStreamPort *createOutputDataStreamPort(const std::string& outputPortDSName, TypeCode* type);
98  virtual InputPort *edAddInputPort(const std::string& inputPortName, TypeCode* type) throw(Exception);
99  virtual OutputPort *edAddOutputPort(const std::string& outputPortName, TypeCode* type) throw(Exception);
100  virtual InputDataStreamPort *edAddInputDataStreamPort(const std::string& inputPortDSName, TypeCode* type) throw(Exception);
101  virtual OutputDataStreamPort *edAddOutputDataStreamPort(const std::string& outputPortDSName, TypeCode* type) throw(Exception);
102  virtual void edOrderInputPorts(const std::list<InputPort*>& ports);
103  virtual void edOrderOutputPorts(const std::list<OutputPort*>& ports);
104 
105  virtual std::string typeName() {return "YACS__ENGINE__ElementaryNode";}
106  virtual void edUpdateState();
107  virtual void ensureLoading();
108 
109  int getMaxLevelOfParallelism() const { return 1; }
110 
111  //run part
112  void begin();
113  bool isReady();
114  void finished();
115  void aborted();
116  void loaded();
117  void connected();
118  virtual std::string getErrorDetails();
119  virtual void initService() { }
120  virtual void connectService() { }
121  virtual void disconnectService() { }
122  virtual void load() { }
123  virtual void getCoupledTasks(std::set<Task*>& coupledSet);
124  virtual void getCoupledNodes(std::set<Task*>& coupledSet);
125  void accept(Visitor *visitor);
126 
127  // Used for runtime nodes that need
128  // to configure their services for the multi property
129  virtual void addDatastreamPortToInitMultiService(const std::string & port_name,
130  int number) {}
131  protected:
132  void initCommonPartWithoutStateManagement(bool start);
133  // Management of multi property
134  virtual void createMultiDatastreamPorts();
135 
136  void edDisconnectAllLinksWithMe();
137  bool areAllInputPortsValid() const;
138  template<class PORT>
139  PORT *getPort(const std::string& name, const std::list<PORT *>& setOfPorts) const throw(Exception);
140  template<class PORT, class ENUMTYPE>
141  PORT *edAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) throw(Exception);
142  template<class PORT, class ENUMTYPE>
143  bool edCheckAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) throw(Exception);
144  template<class PORT>
145  static void edRemovePortTypedFromSet(PORT *port, std::list<PORT *>& setOfPorts) throw(Exception);
146  template<class PORT>
147  static bool isPortNameAlreadyExist(const std::string& portName, const std::list<PORT *>& setOfPorts);
148  };
149 
154  template<class PORT>
155  PORT *ElementaryNode::getPort(const std::string& name, const std::list<PORT *>& setOfPorts) const throw(Exception)
156  {
157  for(typename std::list<PORT *>::const_iterator iter=setOfPorts.begin();iter!=setOfPorts.end();iter++)
158  {
159  if((*iter)->getName()==name)
160  return *iter;
161  }
162  std::string what="ElementaryNode::getPort : unexisting "; what+=PORT::NAME;
163  what+=" with name ";
164  what+=name;
165  throw Exception(what);
166  }
167 
173  template<class PORT, class ENUMTYPE>
174  PORT *ElementaryNode::edAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) throw(Exception)
175  {
176  checkValidityOfPortName(portName);
177  if(isPortNameAlreadyExist<PORT>(portName, setOfPorts))
178  {
179  std::string what="Port of type "; what+=PORT::NAME; what += " with name : "; what+=portName; what+=" already exists";
180  throw Exception(what);
181  }
182  PORT *ret=new PORT(portName,this,type);
183  setOfPorts.push_back(ret);
184  return ret;
185  }
186 
187  template<class PORT, class ENUMTYPE>
188  bool ElementaryNode::edCheckAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) throw(Exception)
189  {
190  checkValidityOfPortName(portName);
191  if(isPortNameAlreadyExist<PORT>(portName, setOfPorts))
192  {
193  std::string what="Port of type "; what+=PORT::NAME; what += " with name : "; what+=portName; what+=" already exists";
194  throw Exception(what);
195  }
196  return true;
197  }
198 
203  template<class PORT>
204  void ElementaryNode::edRemovePortTypedFromSet(PORT *port, std::list<PORT *>& setOfPorts) throw(Exception)
205  {
206  if(!isPortNameAlreadyExist<PORT>(port->getName(), setOfPorts))
207  throw Exception("Port is not part of the list : unable to remove it");
208  typename std::list<PORT *>::iterator iter=std::find(setOfPorts.begin(),setOfPorts.end(),port);
209  if(iter!=setOfPorts.end())
210  {
211  (*iter)->edRemoveAllLinksLinkedWithMe();
212  setOfPorts.erase(iter);
213  }
214  }
215 
220  template<class PORT>
221  bool ElementaryNode::isPortNameAlreadyExist(const std::string& portName, const std::list<PORT *>& setOfPorts)
222  {
223  for(typename std::list<PORT *>::const_iterator iter=setOfPorts.begin();iter!=setOfPorts.end();iter++)
224  {
225  if((*iter)->getName()==portName)
226  return true;
227  }
228  return false;
229  }
230  }
231 }
232 
233 #endif