]> SALOME platform Git repositories - modules/yacs.git/blob - src/yacsloader/switchParsers.hxx
Salome HOME
2711e1b2d1191120362f4d2aa7716f8a54e91ffa
[modules/yacs.git] / src / yacsloader / switchParsers.hxx
1 // Copyright (C) 2006-2019  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