Version: 8.3.0
blocParsers.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 _BLOCPARSER_HXX_
21 #define _BLOCPARSER_HXX_
22 
23 #include "parserBase.hxx"
24 #include "linkParsers.hxx"
25 #include "xmlrpcParsers.hxx"
26 #include "nodeParsers.hxx"
27 #include "inlineParsers.hxx"
28 #include "remoteParsers.hxx"
29 #include "serverParsers.hxx"
30 #include "sinlineParsers.hxx"
31 #include "serviceParsers.hxx"
32 
33 
34 #include "Proc.hxx"
35 #include "Logger.hxx"
36 #include "Runtime.hxx"
37 #include "ForLoop.hxx"
38 #include "ForEachLoop.hxx"
39 #include "OptimizerLoop.hxx"
40 #include "WhileLoop.hxx"
41 #include "Switch.hxx"
42 #include "Bloc.hxx"
43 #include "Exception.hxx"
44 #include "InlineNode.hxx"
45 #include "DataNode.hxx"
46 #include "ServiceNode.hxx"
47 #include "ServiceInlineNode.hxx"
48 #include "OutputDataStreamPort.hxx"
49 #include "InputDataStreamPort.hxx"
50 
51 #include <vector>
52 
53 extern YACS::ENGINE::Proc* currentProc;
54 extern YACS::ENGINE::Runtime* theRuntime;
55 
56 namespace YACS
57 {
58 
59 template <class T=YACS::ENGINE::Bloc*>
60 struct bloctypeParser:parser
61 {
62  static bloctypeParser<T> blocParser;
63 
64  bloctypeParser():parser()
65  {
66  _orders["property"]=0;
67  _orders["inline"]=2;
68  _orders["service"]=2;
69  _orders["server"]=2;
70  _orders["remote"]=2;
71  _orders["sinline"]=2;
72  _orders["node"]=2;
73  _orders["datanode"]=2;
74  _orders["outnode"]=2;
75  _orders["forloop"]=2;
76  _orders["foreach"]=2;
77  _orders["optimizer"]=2;
78  _orders["while"]=2;
79  _orders["switch"]=2;
80  _orders["bloc"]=2;
81  _orders["control"]=3;
82  _orders["datalink"]=3;
83  _orders["stream"]=3;
84  _orders["parameter"]=3;
85  }
86  virtual void onStart(const XML_Char* el, const XML_Char** attr);
87  virtual void onEnd(const char *el,parser* child);
88  virtual void buildAttr(const XML_Char** attr)
89  {
90  if (!attr)
91  return;
92  this->required("name",attr);
93  for (int i = 0; attr[i]; i += 2)
94  {
95  if(std::string(attr[i]) == "name")name(attr[i+1]);
96  if(std::string(attr[i]) == "state")state(attr[i+1]);
97  }
98  }
99  void name (const std::string& name)
100  {
101  }
102  virtual void state (const std::string& name){
103  DEBTRACE( "bloc_state: " << name )
104  _state=name;
105  if(_state == "disabled")
106  {
107  DEBTRACE( "Bloc disabled: " << _bloc->getName())
108  _bloc->exDisabledState();
109  }
110  }
111  virtual void property (const myprop& prop)
112  {
113  DEBTRACE( "property_set: " << prop._name << prop._value )
114  _bloc->setProperty(prop._name,prop._value);
115  }
116  virtual void inline_ (YACS::ENGINE::InlineNode* const& n)
117  {
118  DEBTRACE( "bloc_pynode_set: " << n->getName() )
119  _bloc->edAddChild(n);
120  std::string fullname = currentProc->names.back()+n->getName();
121  currentProc->nodeMap[fullname]=n;
122  currentProc->inlineMap[fullname]=n;
123  }
124  virtual void sinline (YACS::ENGINE::ServiceInlineNode* const& n)
125  {
126  DEBTRACE( "bloc_sinline: " << n->getName() )
127  _bloc->edAddChild(n);
128  std::string fullname = currentProc->names.back()+n->getName();
129  currentProc->nodeMap[fullname]=n;
130  currentProc->serviceMap[fullname]=n;
131  }
132  virtual void service (YACS::ENGINE::ServiceNode* const& n)
133  {
134  DEBTRACE( "bloc_service_set: " << n->getName() )
135  _bloc->edAddChild(n);
136  std::string fullname = currentProc->names.back()+n->getName();
137  currentProc->nodeMap[fullname]=n;
138  currentProc->serviceMap[fullname]=n;
139  }
140  virtual void remote (YACS::ENGINE::InlineNode* const& n)
141  {
142  DEBTRACE( "bloc_remote_set: " << n->getName() )
143  _bloc->edAddChild(n);
144  std::string fullname = currentProc->names.back()+n->getName();
145  currentProc->nodeMap[fullname]=n;
146  currentProc->inlineMap[fullname]=n;
147  }
148  virtual void server (YACS::ENGINE::ServerNode* const& n)
149  {
150  DEBTRACE( "bloc_server_set: " << n->getName() )
151  _bloc->edAddChild(n);
152  std::string fullname = currentProc->names.back()+n->getName();
153  currentProc->nodeMap[fullname]=n;
154  currentProc->inlineMap[fullname]=n;
155  }
156  virtual void node (YACS::ENGINE::InlineNode* const& n)
157  {
158  DEBTRACE( "bloc_node_set: " << n->getName() )
159  _bloc->edAddChild(n);
160  std::string fullname = currentProc->names.back()+n->getName();
161  DEBTRACE( "bloc_node_set fullname = " << fullname )
162  currentProc->nodeMap[fullname]=n;
163  currentProc->inlineMap[fullname]=n;
164  }
165  virtual void forloop (YACS::ENGINE::ForLoop* const& b)
166  {
167  DEBTRACE( "bloc_forloop_set: " << b->getName() )
168  _bloc->edAddChild(b);
169  std::string fullname = currentProc->names.back()+b->getName();
170  currentProc->nodeMap[fullname]=b;
171  }
172  virtual void optimizer (YACS::ENGINE::OptimizerLoop* const& b)
173  {
174  DEBTRACE( "bloc_optimizer_set: " << b->getName() );
175  _bloc->edAddChild(b);
176  std::string fullname = currentProc->names.back()+b->getName();
177  currentProc->nodeMap[fullname]=b;
178  //fullname += ".splitter";
179  //currentProc->nodeMap[fullname]=b->getChildByShortName("splitter");
180  }
181  virtual void foreach (YACS::ENGINE::ForEachLoop* const& b)
182  {
183  DEBTRACE( "bloc_foreach_set: " << b->getName() )
184  _bloc->edAddChild(b);
185  std::string fullname = currentProc->names.back()+b->getName();
186  currentProc->nodeMap[fullname]=b;
187  fullname += ".splitter";
188  currentProc->nodeMap[fullname]=b->getChildByShortName("splitter");
189  }
190  virtual void while_ (YACS::ENGINE::WhileLoop* const& b)
191  {
192  DEBTRACE( "bloc_while_set: " << b->getName() )
193  _bloc->edAddChild(b);
194  std::string fullname = currentProc->names.back()+b->getName();
195  currentProc->nodeMap[fullname]=b;
196  }
197  virtual void switch_ (YACS::ENGINE::Switch* const& b)
198  {
199  DEBTRACE( "bloc_switch_set: " << b->getName() )
200  _bloc->edAddChild(b);
201  std::string fullname = currentProc->names.back()+b->getName();
202  currentProc->nodeMap[fullname]=b;
203  }
204  virtual void bloc (YACS::ENGINE::Bloc* const& b)
205  {
206  DEBTRACE( "bloc_bloc_set: " << b->getName() )
207  _bloc->edAddChild(b);
208  std::string fullname=currentProc->names.back()+ b->getName();
209  currentProc->nodeMap[fullname]=b;
210  }
211  virtual void control (const mycontrol& l)
212  {
213  DEBTRACE( "bloc_control_set: " << l.fromnode() << " "<< l.tonode() )
214  std::string msg;
215 
216  if(currentProc->nodeMap.count(currentProc->names.back()+l.fromnode()) == 0)
217  {
218  msg="from node " + l.fromnode() + " does not exist in control link: ";
219  msg=msg+l.fromnode()+"->"+l.tonode();
220  msg=msg+ " context: "+currentProc->names.back();
221  this->logError(msg);
222  return;
223  }
224  if(currentProc->nodeMap.count(currentProc->names.back()+l.tonode()) == 0)
225  {
226  msg="to node " + l.tonode() + " does not exist in control link: ";
227  msg=msg+l.fromnode()+"->"+l.tonode();
228  msg=msg+ " context: "+currentProc->names.back();
229  this->logError(msg);
230  return;
231  }
232  // We only link local nodes
233  try
234  {
235  _bloc->edAddCFLink(currentProc->nodeMap[currentProc->names.back()+l.fromnode()],
236  currentProc->nodeMap[currentProc->names.back()+l.tonode()]);
237  }
238  catch(YACS::Exception& e)
239  {
240  this->logError(e.what());
241  }
242  }
243  virtual void datalink (const mylink& l)
244  {
245  DEBTRACE( "bloc_datalink_set: "<<l.fromnode()<<"("<<l.fromport()<<")->"<<l.tonode()<<"("<<l.toport()<<")")
246  std::string msg;
247 
248  //Try only relative name for from node
249  std::string fromname = currentProc->names.back()+l.fromnode();
250  if(currentProc->nodeMap.count(fromname) == 0)
251  {
252  msg="from node " + l.fromnode() + " does not exist in data link: ";
253  msg=msg+l.fromnode()+"("+l.fromport()+")->"+l.tonode()+"("+l.toport()+")";
254  this->logError(msg);
255  return;
256  }
257  //Try relative name for to node and then absolute one
258  std::string toname = currentProc->names.back()+l.tonode();
259  if(currentProc->nodeMap.count(toname) == 0)
260  {
261  //It's not a relative name. Try an absolute one (I think it's not possible)
262  toname=l.tonode();
263  if(currentProc->nodeMap.count(toname) == 0)
264  {
265  // The TO node does not exist -> error
266  msg="to node " + l.tonode() + " does not exist in data link: ";
267  msg=msg+l.fromnode()+"("+l.fromport()+")->"+l.tonode()+"("+l.toport()+")";
268  this->logError(msg);
269  return;
270  }
271  }
272  // We only link local node and other nodes (relative or absolute name in this order)
273  DEBTRACE(fromname <<":"<<l.fromport()<<toname<<":"<<l.toport());
274  try
275  {
276  if (l.withControl())
277  _bloc->edAddDFLink(currentProc->nodeMap[fromname]->getOutputPort(l.fromport()),
278  currentProc->nodeMap[toname]->getInputPort(l.toport()));
279  else
280  _bloc->edAddLink(currentProc->nodeMap[fromname]->getOutputPort(l.fromport()),
281  currentProc->nodeMap[toname]->getInputPort(l.toport()));
282  }
283  catch(YACS::Exception& e)
284  {
285  this->logError(e.what());
286  }
287  }
288  virtual void stream (const mystream& l)
289  {
290  DEBTRACE( "bloc_stream_set: " << l.fromnode() << l.fromport() << l.tonode() << l.toport() )
291  std::string msg;
292  std::string fromname = currentProc->names.back()+l.fromnode();
293  std::string toname = currentProc->names.back()+l.tonode();
294  //only relative names
295  if(currentProc->nodeMap.count(fromname) == 0)
296  {
297  msg="from node " + l.fromnode() + " does not exist in stream link: ";
298  msg=msg+l.fromnode()+"("+l.fromport()+")->"+l.tonode()+"("+l.toport()+")";
299  this->logError(msg);
300  return;
301  }
302  if(currentProc->nodeMap.count(toname) == 0)
303  {
304  msg="to node " + l.tonode() + " does not exist in stream link: ";
305  msg=msg+l.fromnode()+"("+l.fromport()+")->"+l.tonode()+"("+l.toport()+")";
306  this->logError(msg);
307  return;
308  }
309  YACS::ENGINE::OutputDataStreamPort* pout=currentProc->nodeMap[fromname]->getOutputDataStreamPort(l.fromport());
310  YACS::ENGINE::InputDataStreamPort* pin=currentProc->nodeMap[toname]->getInputDataStreamPort(l.toport());
311  _bloc->edAddLink(pout,pin);
312  // Set all properties for this link
313  std::map<std::string, std::string>::const_iterator pt;
314  for(pt=l._props.begin();pt!=l._props.end();pt++)
315  {
316  pin->setProperty((*pt).first,(*pt).second);
317  pout->setProperty((*pt).first,(*pt).second);
318  }
319  }
320  virtual void parameter (const myparam& param)
321  {
322  DEBTRACE( "++++++++++++++++++++Parameter+++++++++++++++++++++" );
323  std::string msg;
324  std::string toname = currentProc->names.back()+param._tonode;
325  if(currentProc->nodeMap.count(toname) == 0)
326  {
327  msg="to node " + param._tonode + " does not exist in parameter: ";
328  msg=msg+"->"+param._tonode+"("+param._toport+")";
329  this->logError(msg);
330  return;
331  }
332  YACS::ENGINE::InputPort* inport=currentProc->nodeMap[toname]->getInputPort(param._toport);
333  //We don't know the parameter type. So we try to initialize the port
334  //with the value. If it's not the right type, edInit throws an exception
335  try
336  {
337  inport->edInit("XML",param._value.c_str());
338  }
339  catch(YACS::Exception& e)
340  {
341  this->logError(e.what());
342  }
343  DEBTRACE( "++++++++++++++++++++End parameter+++++++++++++++++++++" );
344  }
345 
346  virtual void preset (ENGINE::DataNode* const& n);
347  virtual void outnode (ENGINE::DataNode* const& n);
348 
349  T post()
350  {
351  DEBTRACE( "bloc_post" )
352  currentProc->names.pop_back();
353  T b=_bloc;
354  _blocs.pop_back();
355  if(_blocs.empty())
356  _bloc=NULL;
357  else
358  _bloc=_blocs.back();
359  return b;
360  }
361 
362  T _bloc;
363  std::string _state;
364  std::vector<YACS::ENGINE::Bloc *> _blocs;
365 };
366 
367 template <class T> bloctypeParser<T> bloctypeParser<T>::blocParser;
368 
369 template <class T>
370 void bloctypeParser<T>::preset (ENGINE::DataNode* const& n)
371 {
372  DEBTRACE("bloc_preset_set: " << n->getName() );
373  _bloc->edAddChild(n);
374  std::string fullname = currentProc->names.back()+n->getName();
375  currentProc->nodeMap[fullname]=n;
376 }
377 
378 template <class T>
379 void bloctypeParser<T>::outnode (ENGINE::DataNode* const& n)
380 {
381  DEBTRACE("bloc_outnode: " << n->getName() );
382  _bloc->edAddChild(n);
383  std::string fullname = currentProc->names.back()+n->getName();
384  currentProc->nodeMap[fullname]=n;
385 }
386 
387 template <>
388 void bloctypeParser<YACS::ENGINE::Bloc*>::name (const std::string& name)
389 {
390  DEBTRACE( "bloc_name: " << name )
391  std::string fullname=currentProc->names.back()+name;
392  _bloc=theRuntime->createBloc(name);
393  _blocs.push_back(_bloc);
394  currentProc->names.push_back(fullname+'.');
395 }
396 
397 }
398 
399 #include "loopParsers.hxx"
400 #include "switchParsers.hxx"
401 #include "presetParsers.hxx"
402 #include "outputParsers.hxx"
403 
404 namespace YACS
405 {
406 
407 template <class T>
408 void bloctypeParser<T>::onStart(const XML_Char* el, const XML_Char** attr)
409 {
410  DEBTRACE( "bloctypeParser::onStart: " << el )
411  std::string element(el);
412  checkOrder(element);
413  parser* pp=&parser::main_parser;
414  if(element == "property")pp=&propertytypeParser::propertyParser;
415 
416  else if(element == "inline")pp=&inlinetypeParser<>::inlineParser;
417  else if(element == "sinline")pp=&sinlinetypeParser<>::sinlineParser;
418  else if(element == "service")pp=&servicetypeParser<>::serviceParser;
419  else if(element == "server")pp=&servertypeParser<>::serverParser;
420  else if(element == "remote")pp=&remotetypeParser<>::remoteParser;
421  else if(element == "node")pp=&nodetypeParser<>::nodeParser;
422  else if(element == "datanode")pp=&presettypeParser<>::presetParser;
423  else if(element == "outnode")pp=&outnodetypeParser<>::outnodeParser;
424 
425  else if(element == "bloc")pp=&bloctypeParser<>::blocParser;
426  else if(element == "forloop")pp=&forlooptypeParser<>::forloopParser;
427  else if(element == "foreach")pp=&foreachlooptypeParser<>::foreachloopParser;
428  else if(element == "optimizer")pp=&optimizerlooptypeParser<>::optimizerloopParser;
429  else if(element == "while")pp=&whilelooptypeParser<>::whileloopParser;
430  else if(element == "switch")pp=&switchtypeParser::switchParser;
431 
432  else if(element == "control")pp=&controltypeParser<>::controlParser;
433  else if(element == "datalink")pp=&linktypeParser<>::linkParser;
434  else if(element == "stream")pp=&streamtypeParser<>::streamParser;
435  else if(element == "parameter")pp=&parametertypeParser::parameterParser;
436 
437  this->SetUserDataAndPush(pp);
438  pp->init();
439  pp->pre();
440  pp->buildAttr(attr);
441 }
442 
443 template <class T>
444 void bloctypeParser<T>::onEnd(const char *el,parser* child)
445 {
446  DEBTRACE( "bloctypeParser::onEnd: " << el )
447  std::string element(el);
448  if(element == "property")property(((propertytypeParser*)child)->post());
449  else if(element == "inline")inline_(((inlinetypeParser<>*)child)->post());
450  else if(element == "sinline")sinline(((sinlinetypeParser<>*)child)->post());
451  else if(element == "service")service(((servicetypeParser<>*)child)->post());
452  else if(element == "server")server(((servertypeParser<>*)child)->post());
453  else if(element == "remote")remote(((remotetypeParser<>*)child)->post());
454  else if(element == "node")node(((nodetypeParser<>*)child)->post());
455  else if(element == "datanode")preset(((presettypeParser<>*)child)->post());
456  else if(element == "outnode")outnode(((outnodetypeParser<>*)child)->post());
457 
458  else if(element == "bloc")bloc(((bloctypeParser<>*)child)->post());
459  else if(element == "forloop")forloop(((forlooptypeParser<>*)child)->post());
460  else if(element == "optimizer")optimizer(((optimizerlooptypeParser<>*)child)->post());
461  else if(element == "foreach")foreach(((foreachlooptypeParser<>*)child)->post());
462  else if(element == "while")while_(((whilelooptypeParser<>*)child)->post());
463  else if(element == "switch")switch_(((switchtypeParser*)child)->post());
464 
465  else if(element == "control") control(((controltypeParser<>*)child)->post());
466  else if(element == "datalink") datalink(((linktypeParser<>*)child)->post());
467  else if(element == "stream") stream(((streamtypeParser<>*)child)->post());
468  else if(element == "parameter") parameter(((parametertypeParser*)child)->post());
469 }
470 
471 }
472 
473 #endif