Version: 8.3.0
switchParsers.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 _SWITCHPARSERS_HXX_
21 #define _SWITCHPARSERS_HXX_
22 
23 #include "parserBase.hxx"
24 #include "propertyParsers.hxx"
25 #include "nodeParsers.hxx"
26 
27 #include "Loop.hxx"
28 #include "ForLoop.hxx"
29 #include "ForEachLoop.hxx"
30 #include "WhileLoop.hxx"
31 #include "Switch.hxx"
32 #include "Bloc.hxx"
33 #include "Proc.hxx"
34 #include "InlineNode.hxx"
35 #include "ServiceNode.hxx"
36 #include "ServiceInlineNode.hxx"
37 #include "Runtime.hxx"
38 
39 #include "factory.hxx"
40 
41 #include <sstream>
42 #include <string>
43 #include <vector>
44 #include <map>
45 
46 extern YACS::ENGINE::Proc* currentProc;
47 extern YACS::ENGINE::Runtime* theRuntime;
48 
49 namespace YACS
50 {
51 
52 struct casetypeParser:parser
53 {
54  static casetypeParser caseParser;
55  void onStart(const XML_Char* el, const XML_Char** attr);
56  void onEnd(const char *el,parser* child);
57  virtual void buildAttr(const XML_Char** attr);
58  virtual void pre ();
59  virtual void id (const int& n);
60  virtual void property (const myprop& prop);
61  virtual void inline_ (ENGINE::InlineNode* const& n);
62  virtual void sinline (ENGINE::ServiceInlineNode* const& n);
63  virtual void service (ENGINE::ServiceNode* const& n);
64  virtual void server (ENGINE::ServerNode* const& n);
65  virtual void remote (ENGINE::InlineNode* const& n);
66  virtual void node (ENGINE::InlineNode* const& n);
67  virtual void forloop (ENGINE::ForLoop* const& n);
68  virtual void foreach (ENGINE::ForEachLoop* const& n);
69  virtual void optimizer (ENGINE::OptimizerLoop* const& n);
70  virtual void while_ (ENGINE::WhileLoop* const& n);
71  virtual void switch_ (ENGINE::Switch* const& n);
72  virtual void bloc (ENGINE::Bloc* const& n);
73  virtual std::pair<int,ENGINE::Node*> post();
74  ENGINE::Node* _cnode;
75  int _id;
76  std::vector<int> _idStack;
77 };
78 
79 struct defaultcasetypeParser:casetypeParser
80 {
81  static defaultcasetypeParser defaultcaseParser;
82  virtual void buildAttr(const XML_Char** attr);
83  virtual void pre ();
84 };
85 
86 struct switchtypeParser:parser
87 {
88  static switchtypeParser switchParser;
89  void onStart(const XML_Char* el, const XML_Char** attr);
90  void onEnd(const char *el,parser* child);
91  virtual void buildAttr(const XML_Char** attr);
92  virtual void pre ();
93  virtual void case_ (const std::pair<int,ENGINE::Node*>& p);
94  virtual void default_ (const std::pair<int,ENGINE::Node*>& p);
95  virtual void name (const std::string& name);
96  virtual void state (const std::string& state);
97  virtual void select (const int& s);
98  virtual ENGINE::Switch* post ();
99  // stack to store switches in case of switch in switch
100  std::vector<ENGINE::Switch *> _cnodes;
101  std::string _state;
102 };
103 
104 }
105 
106 #include "loopParsers.hxx"
107 
108 namespace YACS
109 {
110 
111  static std::string switch_t3[]={"inline","sinline","service","server", "remote", "node","forloop","foreach","optimizer","while","switch","bloc",""};
112 
113  void casetypeParser::buildAttr(const XML_Char** attr)
114  {
115  if (!attr)
116  return;
117  this->required("id",attr);
118  for (int i = 0; attr[i]; i += 2)
119  {
120  if(std::string(attr[i]) == "id")id(atoi(attr[i+1]));
121  }
122  }
123  void casetypeParser::pre ()
124  {
125  _cnode=0;
126  _id=0;
127  }
128  void casetypeParser::id (const int& n)
129  {
130  DEBTRACE( "case_id: " << n )
131  _id=n;
132  //store this level id
133  _idStack.push_back(_id);
134  //store this level name
135  std::stringstream temp;
136  if (_id <0) temp << "m" << -_id << "_";
137  else temp << "p" << _id << "_";
138  std::string fullname=currentProc->names.back()+temp.str();
139  DEBTRACE( "case_fullname: " << fullname )
140  currentProc->names.push_back(fullname);
141  }
142  void casetypeParser::property (const myprop& prop)
143  {
144  DEBTRACE( "property_set: " << prop._name << prop._value )
145  }
146  void casetypeParser::inline_ (ENGINE::InlineNode* const& n)
147  {
148  _cnode=n;
149  std::string fullname=currentProc->names.back()+ n->getName();
150  currentProc->nodeMap[fullname]=n;
151  currentProc->inlineMap[fullname]=n;
152  }
153  void casetypeParser::sinline (ENGINE::ServiceInlineNode* const& n)
154  {
155  _cnode=n;
156  std::string fullname=currentProc->names.back()+ n->getName();
157  currentProc->nodeMap[fullname]=n;
158  currentProc->serviceMap[fullname]=n;
159  }
160  void casetypeParser::service (ENGINE::ServiceNode* const& n)
161  {
162  _cnode=n;
163  std::string fullname=currentProc->names.back()+ n->getName();
164  currentProc->nodeMap[fullname]=n;
165  currentProc->serviceMap[fullname]=n;
166  }
167  void casetypeParser::server (ENGINE::ServerNode* const& n)
168  {
169  _cnode=n;
170  std::string fullname=currentProc->names.back()+ n->getName();
171  currentProc->nodeMap[fullname]=n;
172  currentProc->inlineMap[fullname]=n;
173  }
174  void casetypeParser::remote (ENGINE::InlineNode* const& n)
175  {
176  _cnode=n;
177  std::string fullname=currentProc->names.back()+ n->getName();
178  currentProc->nodeMap[fullname]=n;
179  currentProc->inlineMap[fullname]=n;
180  }
181  void casetypeParser::node (ENGINE::InlineNode* const& n)
182  {
183  _cnode=n;
184  std::string fullname=currentProc->names.back()+ n->getName();
185  currentProc->nodeMap[fullname]=n;
186  currentProc->inlineMap[fullname]=n;
187  }
188  void casetypeParser::forloop (ENGINE::ForLoop* const& n)
189  {
190  _cnode=n;
191  std::string fullname=currentProc->names.back()+ n->getName();
192  currentProc->nodeMap[fullname]=n;
193  }
194  void casetypeParser::foreach (ENGINE::ForEachLoop* const& n)
195  {
196  _cnode=n;
197  std::string fullname=currentProc->names.back()+ n->getName();
198  currentProc->nodeMap[fullname]=n;
199  fullname += ".splitter";
200  currentProc->nodeMap[fullname]=n->getChildByShortName("splitter");
201  }
202  void casetypeParser::optimizer (ENGINE::OptimizerLoop* const& n)
203  {
204  _cnode=n;
205  std::string fullname=currentProc->names.back()+ n->getName();
206  currentProc->nodeMap[fullname]=n;
207  //fullname += ".splitter";
208  //currentProc->nodeMap[fullname]=n->getChildByShortName("splitter");
209  }
210  void casetypeParser::while_ (ENGINE::WhileLoop* const& n)
211  {
212  _cnode=n;
213  std::string fullname=currentProc->names.back()+ n->getName();
214  currentProc->nodeMap[fullname]=n;
215  }
216  void casetypeParser::switch_ (ENGINE::Switch* const& n)
217  {
218  _cnode=n;
219  std::string fullname=currentProc->names.back()+ n->getName();
220  currentProc->nodeMap[fullname]=n;
221  }
222  void casetypeParser::bloc (ENGINE::Bloc* const& n)
223  {
224  _cnode=n;
225  std::string fullname=currentProc->names.back()+ n->getName();
226  currentProc->nodeMap[fullname]=n;
227  }
228  std::pair<int,ENGINE::Node*> casetypeParser::post()
229  {
230  DEBTRACE( "case_post" )
231  minchoice(switch_t3,1);
232  //get back this level id
233  _id=_idStack.back();
234  _idStack.pop_back();
235  //pop back this level name
236  currentProc->names.pop_back();
237  return std::pair<int,ENGINE::Node*>(_id,_cnode);
238  }
239 
240  void defaultcasetypeParser::buildAttr(const XML_Char** attr)
241  {
242  if (!attr)
243  return;
244  for (int i = 0; attr[i]; i += 2)
245  {
246  DEBTRACE( attr[i] << "=" << attr[i + 1] )
247  }
248  }
249  void defaultcasetypeParser::pre ()
250  {
251  _id=0;
252  _cnode=0;
253  //store this level id
254  _idStack.push_back(_id);
255  //store this level name
256  std::string fullname=currentProc->names.back()+"default_";
257  DEBTRACE( "case_fullname: " << fullname )
258  currentProc->names.push_back(fullname);
259  }
260 
261  void switchtypeParser::buildAttr(const XML_Char** attr)
262  {
263  if (!attr)
264  return;
265  this->required("name",attr);
266  for (int i = 0; attr[i]; i += 2)
267  {
268  if(std::string(attr[i]) == "name")name(attr[i+1]);
269  if(std::string(attr[i]) == "state")state(attr[i+1]);
270  if(std::string(attr[i]) == "select")select(atoi(attr[i+1]));
271  }
272  }
273  void switchtypeParser::pre (){_state="";}
274  void switchtypeParser::case_ (const std::pair<int,ENGINE::Node*>& p)
275  {
276  ENGINE::Switch* s=_cnodes.back();
277  s->edSetNode(p.first,p.second);
278  }
279  void switchtypeParser::default_ (const std::pair<int,ENGINE::Node*>& p)
280  {
281  ENGINE::Switch* s=_cnodes.back();
282  s->edSetDefaultNode(p.second);
283  }
284  void switchtypeParser::name (const std::string& name)
285  {
286  ENGINE::Switch* s;
287  std::string fullname=currentProc->names.back()+name;
288  DEBTRACE( "switch_fullname: " << fullname )
289  s=theRuntime->createSwitch(name);
290  _cnodes.push_back(s);
291  currentProc->names.push_back(fullname+'.');
292  }
293  void switchtypeParser::state (const std::string& state)
294  {
295  //state is an attribute (no order). It can be defined before name
296  //To be improved
297  ENGINE::Switch* s=_cnodes.back();
298  if(_state == "disabled")
299  {
300  DEBTRACE( "Switch disabled: " << s->getName())
301  s->exDisabledState();
302  }
303  }
304  void switchtypeParser::select (const int& s)
305  {
306  //select is an attribute
307  ENGINE::Switch* sw=_cnodes.back();
308  ENGINE::InputPort *p=sw->edGetConditionPort();
309  p->edInit(s);
310  }
311  ENGINE::Switch* switchtypeParser::post ()
312  {
313  DEBTRACE( "switch_post: " )
314  ENGINE::Switch* sw=_cnodes.back();
315  //pop back current level name and node
316  _cnodes.pop_back();
317  currentProc->names.pop_back();
318  return sw;
319  }
320 
321 void switchtypeParser::onStart(const XML_Char* el, const XML_Char** attr)
322 {
323  DEBTRACE( "switchtypeParser::onStart: " << el )
324  std::string element(el);
325  this->maxcount("default",1,element);
326  parser* pp=&parser::main_parser;
327  if(element == "case")pp=&casetypeParser::caseParser;
328  else if(element == "default")pp=&defaultcasetypeParser::defaultcaseParser;
329  SetUserDataAndPush(pp);
330  pp->init();
331  pp->pre();
332  pp->buildAttr(attr);
333 }
334 
335 void switchtypeParser::onEnd(const char *el,parser* child)
336 {
337  DEBTRACE( "switchtypeParser::onEnd: " << el )
338  std::string element(el);
339  if(element == "case")case_(((casetypeParser*)child)->post());
340  else if(element == "default")default_(((defaultcasetypeParser*)child)->post());
341 }
342 
343 void casetypeParser::onStart(const XML_Char* el, const XML_Char** attr)
344 {
345  DEBTRACE( "casetypeParser::onStart: " << el )
346  std::string element(el);
347  this->maxcount("inline",1,element);
348  this->maxcount("sinline",1,element);
349  this->maxcount("service",1,element);
350  this->maxcount("server",1,element);
351  this->maxcount("remote",1,element);
352  this->maxcount("node",1,element);
353  this->maxcount("forloop",1,element);
354  this->maxcount("foreach",1,element);
355  this->maxcount("optimizer",1,element);
356  this->maxcount("while",1,element);
357  this->maxcount("switch",1,element);
358  this->maxcount("bloc",1,element);
359  this->maxchoice(switch_t3,1,element);
360  parser* pp=&parser::main_parser;
361  if(element == "property")pp=&propertytypeParser::propertyParser;
362  else if(element == "inline")pp=&inlinetypeParser<>::inlineParser;
363  else if(element == "sinline")pp=&sinlinetypeParser<>::sinlineParser;
364  else if(element == "service")pp=&servicetypeParser<>::serviceParser;
365  else if(element == "server")pp=&servertypeParser<>::serverParser;
366  else if(element == "remote")pp=&remotetypeParser<>::remoteParser;
367  else if(element == "node")pp=&nodetypeParser<>::nodeParser;
368  else if(element == "forloop")pp=&forlooptypeParser<>::forloopParser;
369  else if(element == "foreach")pp=&foreachlooptypeParser<>::foreachloopParser;
370  else if(element == "optimizer")pp=&optimizerlooptypeParser<>::optimizerloopParser;
371  else if(element == "while")pp=&whilelooptypeParser<>::whileloopParser;
372  else if(element == "switch")pp=&switchtypeParser::switchParser;
373  else if(element == "bloc")pp=&bloctypeParser<>::blocParser;
374  SetUserDataAndPush(pp);
375  pp->init();
376  pp->pre();
377  pp->buildAttr(attr);
378 }
379 
380 void casetypeParser::onEnd(const char *el,parser* child)
381 {
382  DEBTRACE( "casetypeParser::onEnd: " << el )
383  std::string element(el);
384  if(element == "property")property(((propertytypeParser*)child)->post());
385  else if(element == "inline")inline_(((inlinetypeParser<>*)child)->post());
386  else if(element == "sinline")sinline(((sinlinetypeParser<>*)child)->post());
387  else if(element == "service")service(((servicetypeParser<>*)child)->post());
388  else if(element == "server")server(((servertypeParser<>*)child)->post());
389  else if(element == "remote")remote(((remotetypeParser<>*)child)->post());
390  else if(element == "node")node(((nodetypeParser<>*)child)->post());
391  else if(element == "forloop")forloop(((forlooptypeParser<>*)child)->post());
392  else if(element == "foreach")foreach(((foreachlooptypeParser<>*)child)->post());
393  else if(element == "optimizer")optimizer(((optimizerlooptypeParser<>*)child)->post());
394  else if(element == "while")while_(((whilelooptypeParser<>*)child)->post());
395  else if(element == "switch")switch_(((switchtypeParser*)child)->post());
396  else if(element == "bloc")bloc(((bloctypeParser<>*)child)->post());
397 }
398 
399 }
400 
401 #endif