]> SALOME platform Git repositories - modules/yacs.git/blob - src/yacsloader/LoadState.cxx
Salome HOME
Deleted deprecated code
[modules/yacs.git] / src / yacsloader / LoadState.cxx
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 #include "LoadState.hxx"
21 #include "Proc.hxx"
22 #include "Node.hxx"
23 #include "ForLoop.hxx"
24 #include "WhileLoop.hxx"
25 #include "Switch.hxx"
26 #include "InGate.hxx"
27 #include "Runtime.hxx"
28 #include "InputPort.hxx"
29 #include "ElementaryNode.hxx"
30
31 #include <iostream>
32 #include <string>
33 #include <cstdlib>
34 #include <cstdarg>
35 #include <cassert>
36
37 //#define _DEVDEBUG_
38 #include "YacsTrace.hxx"
39
40 using namespace YACS::ENGINE;
41 using namespace std;
42
43 XMLReadState    stateParser::_state;
44 std::string     stateParser::_what;
45 std::stack<XMLReadState> stateParser::_stackState;
46 Proc* stateParser::_p;
47 Runtime* stateParser::_runtime;
48 std::map<std::string, YACS::StatesForNode> stateParser::_nodeStateValue;
49 std::map<std::string, YACS::StatesForNode> stateParser::_nodeStates;
50
51 // ----------------------------------------------------------------------------
52 void stateParser::setProc(Proc* p)
53 {
54   _p= p;
55 }
56
57 void stateParser::setRuntime(Runtime* runtime)
58 {
59   _runtime = runtime;
60 }
61
62 void stateParser::init(const xmlChar** p, xmlParserBase* father)
63 {
64   DEBTRACE("stateParser::init()");
65   _state = XMLNOCONTEXT;
66   _father = father;
67   _stackState.push(_state);
68   _nodeStateValue["READY"] =YACS::READY;
69   _nodeStateValue["TOLOAD"] =YACS::TOLOAD;
70   _nodeStateValue["LOADED"] =YACS::LOADED;
71   _nodeStateValue["TOACTIVATE"] =YACS::TOACTIVATE;
72   _nodeStateValue["ACTIVATED"] =YACS::ACTIVATED;
73   _nodeStateValue["DESACTIVATED"] =YACS::DESACTIVATED;
74   _nodeStateValue["DONE"] =YACS::DONE;
75   _nodeStateValue["SUSPENDED"] =YACS::SUSPENDED;
76   _nodeStateValue["LOADFAILED"] =YACS::LOADFAILED;
77   _nodeStateValue["EXECFAILED"] =YACS::EXECFAILED;
78   _nodeStateValue["PAUSE"] =YACS::PAUSE;
79   _nodeStateValue["INTERNALERR"] =YACS::INTERNALERR;
80   _nodeStateValue["DISABLED"] =YACS::DISABLED;
81   _nodeStateValue["FAILED"] =YACS::FAILED;
82   _nodeStateValue["ERROR"] =YACS::ERROR;
83 }
84
85
86 void stateParser::onStart (const XML_Char* elem, const xmlChar** p)
87 {
88   DEBTRACE("stateParser::onStart");
89   string element(elem);
90   stateParser *parser = 0;
91   if (element == "graphState") parser = new graphParser();
92   else
93     { 
94       _what = "expected <graphState>, got <" + element + ">";
95       _state = XMLFATALERROR;
96       stopParse(_what);
97     }
98   if (parser)
99     {
100       _stackParser.push(parser);
101       XML_SetUserData(_xmlParser, parser);
102       parser->init(p);
103     }
104 }
105
106
107 void stateParser::onEnd   (const XML_Char* name)
108 {
109   _stackState.pop();
110   _state = _stackState.top();
111   //cerr << "end " << name << " " << _stackParser.size() << " " << _state << endl;
112 }
113
114
115 void stateParser::charData(std::string data)
116 {
117   //cerr << "data " << data << endl;
118 }
119
120 // ----------------------------------------------------------------------------
121
122 void graphParser::init(const xmlChar** p, xmlParserBase* father)
123 {
124   //  DEBTRACE("graphParser::init()");
125   _state = XMLINGRAPH;
126   _father = father;
127   _stackState.push(_state);
128   if (p) getAttributes(p);
129 }
130
131 void graphParser::onStart (const XML_Char* elem, const xmlChar** p)
132 {
133   string element(elem);
134   stateParser *parser = 0;
135   if (element == "node") parser = new nodeParser();
136   else
137     { 
138       _what = "expected <node>, got <" + element + ">";
139       _state = XMLFATALERROR;
140       stopParse(_what);
141     }
142   if (parser)
143     {
144       _stackParser.push(parser);
145       XML_SetUserData(_xmlParser, parser);
146       parser->init(p, this);
147     }
148 }
149
150
151 void graphParser::onEnd   (const XML_Char* name)
152 {
153   std::map<std::string, YACS::StatesForNode>::const_iterator it;
154   for (it = _nodeStates.begin(); it != _nodeStates.end(); it++)
155     {
156       Node *node =0;
157       string nodeName = it->first;
158       DEBTRACE("nodeName = " << nodeName);
159       if(_p->getName() == nodeName)
160         node = _p;
161       else
162         node = _p->getChildByName(nodeName);
163
164       InGate* inGate = node->getInGate();
165       list<OutGate*> backlinks = inGate->getBackLinks();
166       for (list<OutGate*>::iterator io = backlinks.begin(); io != backlinks.end(); io++)
167         {
168           Node* fromNode = (*io)->getNode();
169           string fromName;
170           if (fromNode == _p) fromName = fromNode->getName();
171           else fromName = _p->getChildName(fromNode);
172           if (_nodeStates[fromName] == YACS::DONE)
173             {
174               DEBTRACE("   fromNode = " << fromName);
175               inGate->setPrecursorDone(*io);
176             }
177         }
178     }
179   stateParser::onEnd(name);
180 }
181
182 // ----------------------------------------------------------------------------
183
184 class outputParser: public stateParser
185 {
186 public:
187   virtual void init(const xmlChar** p, xmlParserBase* father=0)
188   {
189     //DEBTRACE("outputParser::init()");
190     _state = XMLNOCONTEXT;
191     _father = father;
192     YASSERT( dynamic_cast<nodeParser*> (father));
193     _stackState.push(_state);
194     if (p) getAttributes(p);
195   }
196   virtual void onStart (const XML_Char* elem, const xmlChar** p)
197   {
198     //DEBTRACE("outputParser::onStart" << elem);
199     string element(elem);
200     stateParser *parser = 0;
201     if      (element == "name")      parser = new attrParser();
202     else if (element == "value")     parser = new valueParser();
203     else
204     { 
205       _what = "expected name or value, got <" + element + ">";
206       _state = XMLFATALERROR;
207       stopParse(_what);
208     }
209     if (parser)
210     {
211       _stackParser.push(parser);
212       XML_SetUserData(_xmlParser, parser);
213       parser->init(p, this);
214     }
215   }
216   virtual void onEnd   (const XML_Char* name)
217   {
218     //DEBTRACE("outputParser::onEnd" << elem);
219     //DEBTRACE("portName: " << _mapAttrib["name"] << "value: " << _data );
220     stateParser::onEnd(name);
221   }
222   virtual void addData(std::string /*value*/)
223   {
224     //DEBTRACE("outputParser::addData" << elem);
225   }
226 };
227
228 // ----------------------------------------------------------------------------
229
230 void nodeParser::init(const xmlChar** p, xmlParserBase* father)
231 {
232   DEBTRACE("nodeParser::init()");
233   _state = XMLINNODE;
234   _father = father;
235   _stackState.push(_state);
236   if (p) getAttributes(p);
237 }
238
239
240 void nodeParser::onStart (const XML_Char* elem, const xmlChar** p)
241 {
242   DEBTRACE("nodeParser::onStart" << elem);
243   string element(elem);
244   stateParser *parser = 0;
245   if (element == "inputPort")      parser = new portParser();
246   else if (element == "name")      parser = new attrParser();
247   else if (element == "state")     parser = new attrParser();
248   else if (element == "nsteps")    parser = new attrParser();
249   else if (element == "nbdone")    parser = new attrParser();
250   else if (element == "condition") parser = new attrParser();
251   else if (element == "outputPort") parser = new outputParser();
252   else
253     { 
254       _what = "expected name, state or inputPort, got <" + element + ">";
255       _state = XMLFATALERROR;
256       stopParse(_what);
257     }
258   if (parser)
259     {
260       _stackParser.push(parser);
261       XML_SetUserData(_xmlParser, parser);
262       parser->init(p, this);
263     }
264 }
265
266 void nodeParser::onEnd   (const XML_Char* name)
267 {
268   string nodeName = _mapAttrib["name"];
269   string nodeType = _mapAttrib["type"];
270   string nodeState = _mapAttrib["state"];
271   DEBTRACE( "nodeName: " << nodeName << " nodeType: " << nodeType << " nodeState: " << nodeState );
272 //   for (std::map< std::string, Node * >::iterator it=_p->nodeMap.begin(); it != _p->nodeMap.end(); it++)
273 //     cerr << "nodeMap: " << it->first << endl;
274   _nodeStates[nodeName] = _nodeStateValue[nodeState];
275   Node *node =0;
276   if(_p->getName() == nodeName)
277     node=_p;
278   else 
279     node = _p->getChildByName(nodeName);
280
281   YASSERT(_nodeStateValue.find(nodeState) != _nodeStateValue.end());
282   YACS::ENGINE::StateLoader(node, _nodeStateValue[nodeState]);
283
284   if (nodeType == "forLoop")
285     {
286       if (_mapAttrib.find("nsteps") == _mapAttrib.end())
287         {
288           _what = "no attribute nsteps in forLoop " + _mapAttrib["name"];
289           _state = XMLFATALERROR;
290           stopParse(_what);
291         }
292       int nsteps =  atoi(_mapAttrib["nsteps"].c_str());
293
294       if (_mapAttrib.find("nbdone") == _mapAttrib.end())
295         {
296           _what = "no attribute nbdone in forLoop " + _mapAttrib["name"];
297           _state = XMLFATALERROR;
298           stopParse(_what);
299         }
300       int nbdone =  atoi(_mapAttrib["nbdone"].c_str());
301       DEBTRACE("nsteps = " << nsteps << ", nbdone = " << nbdone);
302
303       ForLoop* loop = dynamic_cast<ForLoop*>(node);
304       if (!loop)
305         {
306           _what = "node is not a ForLoop: " + _mapAttrib["name"];
307           _state = XMLFATALERROR;
308           stopParse(_what);
309         }
310       loop->edGetNbOfTimesInputPort()->edInit(nsteps);
311       YACS::ENGINE::NbDoneLoader(loop, nbdone);
312     }
313
314   else if (nodeType == "whileLoop")
315     {
316       if (_mapAttrib.find("nbdone") == _mapAttrib.end())
317         {
318           _what = "no attribute nbdone in forLoop " + _mapAttrib["name"];
319           _state = XMLFATALERROR;
320           stopParse(_what);
321         }
322       int nbdone =  atoi(_mapAttrib["nbdone"].c_str());
323
324       if (_mapAttrib.find("condition") == _mapAttrib.end())
325         {
326           _what = "no attribute condition in forLoop " + _mapAttrib["name"];
327           _state = XMLFATALERROR;
328           stopParse(_what);
329         }
330       bool condition =  atoi(_mapAttrib["condition"].c_str());
331       DEBTRACE("condition = " << condition << ", nbdone = " << nbdone);
332
333       WhileLoop* loop = dynamic_cast<WhileLoop*>(node);
334       if (!loop)
335         {
336           _what = "node is not a WhileLoop: " + _mapAttrib["name"];
337           _state = XMLFATALERROR;
338           stopParse(_what);
339         }
340       loop->edGetConditionPort()->edInit(condition);
341       YACS::ENGINE::NbDoneLoader(loop, nbdone);
342     }
343
344   else if (nodeType == "switch")
345     {
346       if (_mapAttrib.find("condition") == _mapAttrib.end())
347         {
348           _what = "no attribute condition in switch " + _mapAttrib["name"];
349           _state = XMLFATALERROR;
350           stopParse(_what);
351         }
352       int condition =  atoi(_mapAttrib["condition"].c_str());
353       DEBTRACE("condition = " << condition);
354
355       Switch* mySwitch = dynamic_cast<Switch*>(node);
356       if (!mySwitch)
357         {
358           _what = "node is not a Switch: " + _mapAttrib["name"];
359           _state = XMLFATALERROR;
360           stopParse(_what);
361         }
362       mySwitch->edGetConditionPort()->edInit(condition);
363     }
364
365   stateParser::onEnd(name);
366 }
367
368 // ----------------------------------------------------------------------------
369
370 void attrParser::init(const xmlChar** p, xmlParserBase* father)
371 {
372   DEBTRACE("attrParser::init()");
373   //_state = XMLINNODE;
374   _father = father;
375   _stackState.push(_state); // keep current state
376   if (p) getAttributes(p);
377 }
378
379
380 void attrParser::onStart (const XML_Char* elem, const xmlChar** p)
381 {
382   string element(elem);
383   _what = "expected nothing, got <" + element + ">";
384   _state = XMLFATALERROR;
385   stopParse(_what);
386 }
387
388 void attrParser::charData(std::string data)
389 {
390   _attrValue = data;
391 }
392
393 void attrParser::onEnd   (const XML_Char* name)
394 {
395   // cerr << "end attrParser " << name << " " << _stackParser.size() << endl;
396   YASSERT(_father);
397   _father->setAttribute((char*)name, _attrValue);
398   stateParser::onEnd(name);
399 }
400
401 // ----------------------------------------------------------------------------
402
403 void portParser::init(const xmlChar** p, xmlParserBase* father)
404 {
405   DEBTRACE("portParser::init()");
406   _state = XMLINPORT;
407   _father = father;
408   YASSERT( dynamic_cast<nodeParser*> (father));
409   _stackState.push(_state);
410   if (p) getAttributes(p);
411 }
412
413
414 void portParser::onStart (const XML_Char* elem, const xmlChar** p)
415 {
416   DEBTRACE("portParser::onStart" << elem);
417   string element(elem);
418   stateParser *parser = 0;
419   if      (element == "name")      parser = new attrParser();
420   else if (element == "value")     parser = new valueParser();
421   else
422     { 
423       _what = "expected name or value, got <" + element + ">";
424       _state = XMLFATALERROR;
425       stopParse(_what);
426     }
427   if (parser)
428     {
429       _stackParser.push(parser);
430       XML_SetUserData(_xmlParser, parser);
431       parser->init(p, this);
432     }
433 }
434
435 void portParser::addData(std::string value)
436 {
437   _data = value;
438 }
439
440 void portParser::onEnd   (const XML_Char* name)
441 {
442   DEBTRACE("portName: " << _mapAttrib["name"] << "value: " << _data );
443   string nodeName = _father->getAttribute("name");
444   string nodeType = _father->getAttribute("type");
445   Node *node = _p->getChildByName(nodeName);
446   if (nodeType == "elementaryNode")
447     {
448       ElementaryNode* eNode = dynamic_cast<ElementaryNode*>(node);
449       YASSERT(eNode);
450       InputPort *port = eNode->getInputPort(_mapAttrib["name"]);
451       if(_data != "")
452         port->edInit("XML",_data.c_str());
453     }
454   else if (nodeType == "forLoop")
455     {
456       string what="no way to set a port value on port " +  _mapAttrib["name"];
457       what += " in node " + nodeName + " of type " + nodeType;
458       throw Exception(what);
459     }
460   else if (nodeType == "whileLoop")
461     {
462       string what="no way to set a port value on port " +  _mapAttrib["name"];
463       what += " in node " + nodeName + " of type " + nodeType;
464       throw Exception(what);
465     }
466   else if (nodeType == "switch")
467     {
468       string what="no way to set a port value on port " +  _mapAttrib["name"];
469       what += " in node " + nodeName + " of type " + nodeType;
470       throw Exception(what);
471     }
472   else if (nodeType == "foreachLoop")
473     {
474       string what="no way to set a port value on port " +  _mapAttrib["name"];
475       what += " in node " + nodeName + " of type " + nodeType;
476       throw Exception(what);
477     }
478   else 
479     {
480       string what="no way to set a port value on port " +  _mapAttrib["name"];
481       what += " in node " + nodeName + " of type " + nodeType;
482       throw Exception(what);
483     }
484
485   stateParser::onEnd(name);
486 }
487
488 // ----------------------------------------------------------------------------
489
490 void valueParser::init(const xmlChar** p, xmlParserBase* father)
491 {
492   DEBTRACE("valueParser::init()");
493   _state = XMLINVALUE;
494   _father = father;
495   _stackState.push(_state);
496   if (p) getAttributes(p);
497 }
498
499
500 void valueParser::onStart (const XML_Char* elem, const xmlChar** p)
501 {
502   string element(elem);
503   DEBTRACE("value type " << element );
504   stateParser *parser = 0;
505   if      (element == "data")      parser = new dataParser();
506   else if (element == "array")     parser = new arrayParser();
507   else                             parser = new simpleTypeParser();
508   if (parser)
509     {
510       _stackParser.push(parser);
511       XML_SetUserData(_xmlParser, parser);
512       parser->init(p, this);
513     }
514 }
515
516 void valueParser::addData(std::string value)
517 {
518   _data = "<value>" + value + "</value>";
519 }
520
521 void valueParser::onEnd   (const XML_Char* name)
522 {
523   DEBTRACE( _data );
524   _father->addData(_data);
525   string elem = (char *) name;
526   //if (elem == "value" || elem == "data" || elem == "array")
527   stateParser::onEnd(name);
528   //else YASSERT(0); //DEBTRACE("valueParser::onEnd " << elem);
529 }
530
531 // ----------------------------------------------------------------------------
532
533 void arrayParser::init(const xmlChar** p, xmlParserBase* father)
534 {
535   DEBTRACE("arrayParser::init()");
536   _state = XMLINVALUE;
537   _father = father;
538   _stackState.push(_state);
539   if (p) getAttributes(p);
540 }
541
542
543 void arrayParser::onStart (const XML_Char* elem, const xmlChar** p)
544 {
545   string element(elem);
546   DEBTRACE("array type " << element);
547   stateParser *parser = 0;
548   if      (element == "data")      parser = new dataParser();
549   else
550     { 
551       _what = "expected data, got <" + element + ">";
552       _state = XMLFATALERROR;
553       stopParse(_what);
554     }
555   if (parser)
556     {
557       _stackParser.push(parser);
558       XML_SetUserData(_xmlParser, parser);
559       parser->init(p, this);
560     }
561 }
562
563 void arrayParser::addData(std::string value)
564 {
565   string val = "<array>" + value + "</array>";
566   _data = val;
567 }
568
569
570 void arrayParser::onEnd   (const XML_Char* name)
571 {
572   // cerr << "arrayParser::onEnd " << name << endl;
573   // cerr << _data << endl;
574   _father->addData(_data);
575   stateParser::onEnd(name);
576 }
577
578 // ----------------------------------------------------------------------------
579
580 void dataParser::init(const xmlChar** p, xmlParserBase* father)
581 {
582   DEBTRACE("dataParser::init()");
583   _state = XMLINVALUE;
584   _father = father;
585   _stackState.push(_state);
586   if (p) getAttributes(p);
587 }
588
589
590 void dataParser::onStart (const XML_Char* elem, const xmlChar** p)
591 {
592   string element(elem);
593   DEBTRACE("data type " << element );
594   stateParser *parser = 0;
595   if      (element == "value")      parser = new valueParser();
596   else
597     { 
598       _what = "expected value, got <" + element + ">";
599       _state = XMLFATALERROR;
600       stopParse(_what);
601     }
602   if (parser)
603     {
604       _stackParser.push(parser);
605       XML_SetUserData(_xmlParser, parser);
606       parser->init(p, this);
607     }
608 }
609
610 void dataParser::addData(std::string value)
611 {
612   _dataList.push_back(value);
613 }
614
615 void dataParser::onEnd   (const XML_Char* name)
616 {
617   // cerr << "dataParser::onEnd " << name << endl;
618   string val = "<data>";
619   while (!_dataList.empty())
620     {
621       val += _dataList.front();
622       _dataList.pop_front();
623     }
624   val += "</data>";
625   // cerr << val << endl;
626   _father->addData(val);
627   stateParser::onEnd(name);
628 }
629
630 // ----------------------------------------------------------------------------
631
632 void simpleTypeParser::init(const xmlChar** p, xmlParserBase* father)
633 {
634   DEBTRACE("simpleTypeParser::init()");
635   _state = XMLINVALUE;
636   _father = father;
637   _stackState.push(_state);
638   if (p) getAttributes(p);
639 }
640
641 void simpleTypeParser::onStart (const XML_Char* elem, const xmlChar** p)
642 {
643   string element(elem);
644   _what = "expected nothing, got <" + element + ">";
645   _state = XMLFATALERROR;
646   stopParse(_what);
647 }
648
649 void simpleTypeParser::onEnd   (const XML_Char* name)
650 {
651   string val = string("<") + (char*) name + ">" + _data + "</"  + (char*) name +">";
652   DEBTRACE( val );
653   _father->addData(val);
654   stateParser::onEnd(name);
655 }
656
657 void simpleTypeParser::charData(std::string data)
658 {
659   _data = _data + data;
660 }
661
662
663
664 // ----------------------------------------------------------------------------
665
666 stateLoader::stateLoader(xmlParserBase* parser,
667                          YACS::ENGINE::Proc* p) : xmlReader(parser)
668 {
669   _runtime = getRuntime();
670   _p = p;
671 }
672
673 void stateLoader::parse(std::string xmlState)
674 {
675   DEBTRACE("stateLoader::parse");
676   stateParser *parser = dynamic_cast<stateParser*> (_rootParser);
677   parser->setProc(_p);
678   parser->setRuntime(_runtime);
679
680   xmlReader::parse(xmlState);
681
682   DEBTRACE(parser->_state);
683   switch (parser->_state)
684     {
685     case XMLNOCONTEXT:
686     case XMLDONE:
687       {
688         DEBTRACE("parse OK");
689         break;
690       }
691     case XMLFATALERROR:
692       {
693         string what = "Abort Parse: " + parser->_what;
694         throw Exception(what);
695         break;
696       }
697     default:
698       {
699         string what = "Abort Parse: unknown execution problem";
700         throw Exception(what);
701         break;
702       }
703     }
704 }
705
706 void YACS::ENGINE::loadState(YACS::ENGINE::Proc *p,const std::string& xmlStateFile)
707 {
708   DEBTRACE("YACS::ENGINE::loadState");
709   p->init();
710   p->exUpdateState();
711   stateParser* rootParser = new stateParser();
712   stateLoader myStateLoader(rootParser, p);
713   myStateLoader.parse(xmlStateFile);
714 }