Version: 8.3.0
LoadState.cxx
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 #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 #include "ForEachLoop.hxx"
31 #include "Any.hxx"
32 #include "TypeConversions.hxx"
33 
34 #include <iostream>
35 #include <string>
36 #include <cstdlib>
37 #include <cstdarg>
38 #include <cassert>
39 
40 //#define _DEVDEBUG_
41 #include "YacsTrace.hxx"
42 
43 using namespace YACS::ENGINE;
44 using namespace std;
45 
46 XMLReadState stateParser::_state;
47 std::string stateParser::_what;
48 std::stack<XMLReadState> stateParser::_stackState;
49 Proc* stateParser::_p;
50 Runtime* stateParser::_runtime;
51 std::map<std::string, YACS::StatesForNode> stateParser::_nodeStateValue;
52 std::map<std::string, YACS::StatesForNode> stateParser::_nodeStates;
53 
54 // ----------------------------------------------------------------------------
55 void stateParser::setProc(Proc* p)
56 {
57  _p= p;
58 }
59 
60 void stateParser::setRuntime(Runtime* runtime)
61 {
62  _runtime = runtime;
63 }
64 
65 void stateParser::init(const xmlChar** p, xmlParserBase* father)
66 {
67  DEBTRACE("stateParser::init()");
68  _state = XMLNOCONTEXT;
69  _father = father;
70  _stackState.push(_state);
71  _nodeStateValue["READY"] =YACS::READY;
72  _nodeStateValue["TOLOAD"] =YACS::TOLOAD;
73  _nodeStateValue["LOADED"] =YACS::LOADED;
74  _nodeStateValue["TOACTIVATE"] =YACS::TOACTIVATE;
75  _nodeStateValue["ACTIVATED"] =YACS::ACTIVATED;
76  _nodeStateValue["DESACTIVATED"] =YACS::DESACTIVATED;
77  _nodeStateValue["DONE"] =YACS::DONE;
78  _nodeStateValue["SUSPENDED"] =YACS::SUSPENDED;
79  _nodeStateValue["LOADFAILED"] =YACS::LOADFAILED;
80  _nodeStateValue["EXECFAILED"] =YACS::EXECFAILED;
81  _nodeStateValue["PAUSE"] =YACS::PAUSE;
82  _nodeStateValue["INTERNALERR"] =YACS::INTERNALERR;
83  _nodeStateValue["DISABLED"] =YACS::DISABLED;
84  _nodeStateValue["FAILED"] =YACS::FAILED;
85  _nodeStateValue["ERROR"] =YACS::ERROR;
86  _nodeStates.clear();
87 }
88 
89 
90 void stateParser::onStart (const XML_Char* elem, const xmlChar** p)
91 {
92  DEBTRACE("stateParser::onStart");
93  string element(elem);
94  stateParser *parser = 0;
95  if (element == "graphState") parser = new graphParser();
96  else
97  {
98  _what = "expected <graphState>, got <" + element + ">";
99  _state = XMLFATALERROR;
100  stopParse(_what);
101  }
102  if (parser)
103  {
104  _stackParser.push(parser);
105  XML_SetUserData(_xmlParser, parser);
106  parser->init(p);
107  }
108 }
109 
110 
111 void stateParser::onEnd (const XML_Char* name)
112 {
113  _stackState.pop();
114  _state = _stackState.top();
115  //cerr << "end " << name << " " << _stackParser.size() << " " << _state << endl;
116 }
117 
118 
119 void stateParser::charData(std::string data)
120 {
121  //cerr << "data " << data << endl;
122 }
123 
124 // ----------------------------------------------------------------------------
125 
126 void graphParser::init(const xmlChar** p, xmlParserBase* father)
127 {
128  // DEBTRACE("graphParser::init()");
129  _state = XMLINGRAPH;
130  _father = father;
131  _stackState.push(_state);
132  if (p) getAttributes(p);
133 }
134 
135 void graphParser::onStart (const XML_Char* elem, const xmlChar** p)
136 {
137  string element(elem);
138  stateParser *parser = 0;
139  if (element == "node") parser = new nodeParser();
140  else
141  {
142  _what = "expected <node>, got <" + element + ">";
143  _state = XMLFATALERROR;
144  stopParse(_what);
145  }
146  if (parser)
147  {
148  _stackParser.push(parser);
149  XML_SetUserData(_xmlParser, parser);
150  parser->init(p, this);
151  }
152 }
153 
154 
155 void graphParser::onEnd (const XML_Char* name)
156 {
157  std::map<std::string, YACS::StatesForNode>::const_iterator it;
158  for (it = _nodeStates.begin(); it != _nodeStates.end(); it++)
159  {
160  Node *node =0;
161  string nodeName = it->first;
162  DEBTRACE("nodeName = " << nodeName);
163  if(_p->getName() == nodeName)
164  node = _p;
165  else
166  node = _p->getChildByName(nodeName);
167 
168  InGate* inGate = node->getInGate();
169  list<OutGate*> backlinks = inGate->getBackLinks();
170  for (list<OutGate*>::iterator io = backlinks.begin(); io != backlinks.end(); io++)
171  {
172  Node* fromNode = (*io)->getNode();
173  string fromName;
174  if (fromNode == _p) fromName = fromNode->getName();
175  else fromName = _p->getChildName(fromNode);
176  if (_nodeStates[fromName] == YACS::DONE)
177  {
178  DEBTRACE(" fromNode = " << fromName);
179  inGate->setPrecursorDone(*io);
180  }
181  }
182  }
183  stateParser::onEnd(name);
184 }
185 
186 // ----------------------------------------------------------------------------
187 
188 class outputParser: public stateParser
189 {
190 public:
191  virtual void init(const xmlChar** p, xmlParserBase* father=0)
192  {
193  //DEBTRACE("outputParser::init()");
194  _state = XMLNOCONTEXT;
195  _father = father;
196  YASSERT( dynamic_cast<nodeParser*> (father));
197  _stackState.push(_state);
198  if (p) getAttributes(p);
199  }
200  virtual void onStart (const XML_Char* elem, const xmlChar** p)
201  {
202  //DEBTRACE("outputParser::onStart" << elem);
203  string element(elem);
204  stateParser *parser = 0;
205  if (element == "name") parser = new attrParser();
206  else if (element == "value") parser = new valueParser();
207  else
208  {
209  _what = "expected name or value, got <" + element + ">";
210  _state = XMLFATALERROR;
211  stopParse(_what);
212  }
213  if (parser)
214  {
215  _stackParser.push(parser);
216  XML_SetUserData(_xmlParser, parser);
217  parser->init(p, this);
218  }
219  }
220  virtual void onEnd (const XML_Char* name)
221  {
222  //DEBTRACE("outputParser::onEnd" << elem);
223  //DEBTRACE("portName: " << _mapAttrib["name"] << "value: " << _data );
224  stateParser::onEnd(name);
225  }
226  virtual void addData(std::string /*value*/)
227  {
228  //DEBTRACE("outputParser::addData" << elem);
229  }
230 };
231 
232 // ----------------------------------------------------------------------------
233 
234 void nodeParser::init(const xmlChar** p, xmlParserBase* father)
235 {
236  DEBTRACE("nodeParser::init()");
237  _loopSamples.clear();
238  _state = XMLINNODE;
239  _father = father;
240  _stackState.push(_state);
241  if (p) getAttributes(p);
242 }
243 
244 
245 void nodeParser::onStart (const XML_Char* elem, const xmlChar** p)
246 {
247  DEBTRACE("nodeParser::onStart" << elem);
248  string element(elem);
249  stateParser *parser = 0;
250  if (element == "inputPort") parser = new portParser();
251  else if (element == "name") parser = new attrParser();
252  else if (element == "state") parser = new attrParser();
253  else if (element == "nsteps") parser = new attrParser();
254  else if (element == "nbdone") parser = new attrParser();
255  else if (element == "condition") parser = new attrParser();
256  else if (element == "outputPort") parser = new outputParser();
257  else if (element == "loopOutputPort")
258  {
259  loopPortParser* sparser = new loopPortParser();
260  _loopSamples.push_back(sparser);
261  parser = sparser;
262  }
263  else
264  {
265  _what = "expected name, state or inputPort, got <" + element + ">";
266  _state = XMLFATALERROR;
267  stopParse(_what);
268  }
269  if (parser)
270  {
271  _stackParser.push(parser);
272  XML_SetUserData(_xmlParser, parser);
273  parser->init(p, this);
274  }
275 }
276 
277 void nodeParser::onEnd (const XML_Char* name)
278 {
279  string nodeName = _mapAttrib["name"];
280  string nodeType = _mapAttrib["type"];
281  string nodeState = _mapAttrib["state"];
282  DEBTRACE( "nodeName: " << nodeName << " nodeType: " << nodeType << " nodeState: " << nodeState );
283 // for (std::map< std::string, Node * >::iterator it=_p->nodeMap.begin(); it != _p->nodeMap.end(); it++)
284 // cerr << "nodeMap: " << it->first << endl;
285  _nodeStates[nodeName] = _nodeStateValue[nodeState];
286  Node *node =0;
287  if(_p->getName() == nodeName)
288  node=_p;
289  else
290  node = _p->getChildByName(nodeName);
291 
292  YASSERT(_nodeStateValue.find(nodeState) != _nodeStateValue.end());
293  YACS::ENGINE::StateLoader(node, _nodeStateValue[nodeState]);
294 
295  if (nodeType == "forLoop")
296  {
297  if (_mapAttrib.find("nsteps") == _mapAttrib.end())
298  {
299  _what = "no attribute nsteps in forLoop " + _mapAttrib["name"];
300  _state = XMLFATALERROR;
301  stopParse(_what);
302  }
303  int nsteps = atoi(_mapAttrib["nsteps"].c_str());
304 
305  if (_mapAttrib.find("nbdone") == _mapAttrib.end())
306  {
307  _what = "no attribute nbdone in forLoop " + _mapAttrib["name"];
308  _state = XMLFATALERROR;
309  stopParse(_what);
310  }
311  int nbdone = atoi(_mapAttrib["nbdone"].c_str());
312  DEBTRACE("nsteps = " << nsteps << ", nbdone = " << nbdone);
313 
314  ForLoop* loop = dynamic_cast<ForLoop*>(node);
315  if (!loop)
316  {
317  _what = "node is not a ForLoop: " + _mapAttrib["name"];
318  _state = XMLFATALERROR;
319  stopParse(_what);
320  }
321  loop->edGetNbOfTimesInputPort()->edInit(nsteps);
322  YACS::ENGINE::NbDoneLoader(loop, nbdone);
323  }
324 
325  else if (nodeType == "whileLoop")
326  {
327  if (_mapAttrib.find("nbdone") == _mapAttrib.end())
328  {
329  _what = "no attribute nbdone in forLoop " + _mapAttrib["name"];
330  _state = XMLFATALERROR;
331  stopParse(_what);
332  }
333  int nbdone = atoi(_mapAttrib["nbdone"].c_str());
334 
335  if (_mapAttrib.find("condition") == _mapAttrib.end())
336  {
337  _what = "no attribute condition in forLoop " + _mapAttrib["name"];
338  _state = XMLFATALERROR;
339  stopParse(_what);
340  }
341  bool condition = atoi(_mapAttrib["condition"].c_str());
342  DEBTRACE("condition = " << condition << ", nbdone = " << nbdone);
343 
344  WhileLoop* loop = dynamic_cast<WhileLoop*>(node);
345  if (!loop)
346  {
347  _what = "node is not a WhileLoop: " + _mapAttrib["name"];
348  _state = XMLFATALERROR;
349  stopParse(_what);
350  }
351  loop->edGetConditionPort()->edInit(condition);
352  YACS::ENGINE::NbDoneLoader(loop, nbdone);
353  }
354 
355  else if (nodeType == "switch")
356  {
357  if (_mapAttrib.find("condition") == _mapAttrib.end())
358  {
359  _what = "no attribute condition in switch " + _mapAttrib["name"];
360  _state = XMLFATALERROR;
361  stopParse(_what);
362  }
363  int condition = atoi(_mapAttrib["condition"].c_str());
364  DEBTRACE("condition = " << condition);
365 
366  Switch* mySwitch = dynamic_cast<Switch*>(node);
367  if (!mySwitch)
368  {
369  _what = "node is not a Switch: " + _mapAttrib["name"];
370  _state = XMLFATALERROR;
371  stopParse(_what);
372  }
373  mySwitch->edGetConditionPort()->edInit(condition);
374  }
375  else if (nodeType == "forEachLoop")
376  {
377  ForEachLoop* feNode = dynamic_cast<ForEachLoop*>(node);
378  if(!feNode)
379  {
380  _what = "node is not a ForEachLoop: " + _mapAttrib["name"];
381  _state = XMLFATALERROR;
382  stopParse(_what);
383  }
384  else
385  {
386  std::vector<unsigned int> passedIds;
387  std::vector<SequenceAny *> passedOutputs;
388  std::vector<std::string> nameOfOutputs;
389  bool firstPort = true;
390  std::list<loopPortParser*>::const_iterator itPort;
391  for(itPort=_loopSamples.begin(); itPort!=_loopSamples.end(); itPort++)
392  {
393  const std::string& portName =(*itPort)->getPortName();
394  nameOfOutputs.push_back(portName);
395  const YACS::ENGINE::TypeCode* tc = feNode->getOutputPortType(portName);
396  if(!tc)
397  {
398  _what = "Impossible to find the type of the port " + portName;
399  _state = XMLFATALERROR;
400  stopParse(_what);
401  return;
402  }
403  unsigned int nbSamples = (*itPort)->getNbSamples();
404  SequenceAny* seqValues = SequenceAny::New(tc, nbSamples);
405  passedOutputs.push_back(seqValues);
406  for(unsigned int i = 0; i < nbSamples; i++)
407  {
408  unsigned int sampleId = (*itPort)->getSampleId(i);
409  const std::string& sampleData = (*itPort)->getSampleData(i);
410  Any* value = xmlToAny(sampleData, tc);
411  if(firstPort)
412  {
413  passedIds.push_back(sampleId);
414  seqValues->setEltAtRank(i, value);
415  }
416  else
417  {
418  unsigned int pos = 0;
419  while(pos < passedIds.size() && sampleId != passedIds[pos])
420  pos++;
421  if(pos < passedIds.size())
422  seqValues->setEltAtRank(pos, value);
423  else
424  {
425  _what = "Inconsistent sample id in foreach node " + _mapAttrib["name"];
426  _state = XMLFATALERROR;
427  stopParse(_what);
428  itPort=_loopSamples.end();
429  return;
430  }
431  }
432  }
433  firstPort = false;
434  }
435  feNode->assignPassedResults(passedIds, passedOutputs, nameOfOutputs);
436  }
437  }
438 
439  stateParser::onEnd(name);
440 }
441 
442 Any* nodeParser::xmlToAny(const std::string& data, const YACS::ENGINE::TypeCode* tc)const
443 {
444  xmlDocPtr doc;
445  xmlNodePtr cur;
446  //YACS::ENGINE::Any *ob=YACS::ENGINE::AtomAny::New(0);
447  YACS::ENGINE::Any *ob=NULL;
448  {
449  doc = xmlParseMemory(data.c_str(), data.length());
450  if (doc == NULL )
451  {
452  stringstream msg;
453  msg << "Problem in conversion: XML Document not parsed successfully ";
454  msg << " (" << __FILE__ << ":" << __LINE__ << ")";
455  throw ConversionException(msg.str());
456  }
457  cur = xmlDocGetRootElement(doc);
458  if (cur == NULL)
459  {
460  xmlFreeDoc(doc);
461  stringstream msg;
462  msg << "Problem in conversion: empty XML Document";
463  msg << " (" << __FILE__ << ":" << __LINE__ << ")";
464  throw ConversionException(msg.str());
465  }
466  while (cur != NULL)
467  {
468  if ((!xmlStrcmp(cur->name, (const xmlChar *)"value")))
469  {
470  ob=convertXmlNeutral(tc,doc,cur);
471  break;
472  }
473  cur = cur->next;
474  }
475  xmlFreeDoc(doc);
476  if(ob==NULL)
477  {
478  stringstream msg;
479  msg << "Problem in conversion: incorrect XML value";
480  msg << " (" << __FILE__ << ":" << __LINE__ << ")";
481  throw ConversionException(msg.str());
482  }
483  }
484  return ob;
485 }
486 
487 // ----------------------------------------------------------------------------
488 
489 void attrParser::init(const xmlChar** p, xmlParserBase* father)
490 {
491  DEBTRACE("attrParser::init()");
492  //_state = XMLINNODE;
493  _father = father;
494  _stackState.push(_state); // keep current state
495  if (p) getAttributes(p);
496 }
497 
498 
499 void attrParser::onStart (const XML_Char* elem, const xmlChar** p)
500 {
501  string element(elem);
502  _what = "expected nothing, got <" + element + ">";
503  _state = XMLFATALERROR;
504  stopParse(_what);
505 }
506 
507 void attrParser::charData(std::string data)
508 {
509  _attrValue = data;
510 }
511 
512 void attrParser::onEnd (const XML_Char* name)
513 {
514  // cerr << "end attrParser " << name << " " << _stackParser.size() << endl;
515  YASSERT(_father);
516  _father->setAttribute((char*)name, _attrValue);
517  stateParser::onEnd(name);
518 }
519 
520 // ----------------------------------------------------------------------------
521 
522 void portParser::init(const xmlChar** p, xmlParserBase* father)
523 {
524  DEBTRACE("portParser::init()");
525  _state = XMLINPORT;
526  _father = father;
527  YASSERT( dynamic_cast<nodeParser*> (father));
528  _stackState.push(_state);
529  if (p) getAttributes(p);
530 }
531 
532 
533 void portParser::onStart (const XML_Char* elem, const xmlChar** p)
534 {
535  DEBTRACE("portParser::onStart" << elem);
536  string element(elem);
537  stateParser *parser = 0;
538  if (element == "name") parser = new attrParser();
539  else if (element == "value") parser = new valueParser();
540  else
541  {
542  _what = "expected name or value, got <" + element + ">";
543  _state = XMLFATALERROR;
544  stopParse(_what);
545  }
546  if (parser)
547  {
548  _stackParser.push(parser);
549  XML_SetUserData(_xmlParser, parser);
550  parser->init(p, this);
551  }
552 }
553 
554 void portParser::addData(std::string value)
555 {
556  _data = value;
557 }
558 
559 void portParser::onEnd (const XML_Char* name)
560 {
561  DEBTRACE("portName: " << _mapAttrib["name"] << "value: " << _data );
562  string nodeName = _father->getAttribute("name");
563  string nodeType = _father->getAttribute("type");
564  Node *node = _p->getChildByName(nodeName);
565  if (nodeType == "elementaryNode")
566  {
567  ElementaryNode* eNode = dynamic_cast<ElementaryNode*>(node);
568  YASSERT(eNode);
569  InputPort *port = eNode->getInputPort(_mapAttrib["name"]);
570  if(_data != "")
571  port->edInit("XML",_data.c_str());
572  }
573  else if (nodeType == "forLoop")
574  {
575  string what="no way to set a port value on port " + _mapAttrib["name"];
576  what += " in node " + nodeName + " of type " + nodeType;
577  throw Exception(what);
578  }
579  else if (nodeType == "whileLoop")
580  {
581  string what="no way to set a port value on port " + _mapAttrib["name"];
582  what += " in node " + nodeName + " of type " + nodeType;
583  throw Exception(what);
584  }
585  else if (nodeType == "switch")
586  {
587  string what="no way to set a port value on port " + _mapAttrib["name"];
588  what += " in node " + nodeName + " of type " + nodeType;
589  throw Exception(what);
590  }
591  else if (nodeType == "forEachLoop")
592  {
593  ForEachLoop* eNode = dynamic_cast<ForEachLoop*>(node);
594  YASSERT(eNode);
595  InputPort *port = eNode->getInputPort(_mapAttrib["name"]);
596  if(_data != "")
597  port->edInit("XML",_data.c_str());
598  }
599  else
600  {
601  string what="no way to set a port value on port " + _mapAttrib["name"];
602  what += " in node " + nodeName + " of type " + nodeType;
603  throw Exception(what);
604  }
605 
606  stateParser::onEnd(name);
607 }
608 
609 // ----------------------------------------------------------------------------
610 
611 void valueParser::init(const xmlChar** p, xmlParserBase* father)
612 {
613  DEBTRACE("valueParser::init()");
614  _state = XMLINVALUE;
615  _father = father;
616  _stackState.push(_state);
617  if (p) getAttributes(p);
618 }
619 
620 
621 void valueParser::onStart (const XML_Char* elem, const xmlChar** p)
622 {
623  string element(elem);
624  DEBTRACE("value type " << element );
625  stateParser *parser = 0;
626  if (element == "data") parser = new dataParser();
627  else if (element == "array") parser = new arrayParser();
628  else parser = new simpleTypeParser();
629  if (parser)
630  {
631  _stackParser.push(parser);
632  XML_SetUserData(_xmlParser, parser);
633  parser->init(p, this);
634  }
635 }
636 
637 void valueParser::addData(std::string value)
638 {
639  _data = "<value>" + value + "</value>";
640 }
641 
642 void valueParser::onEnd (const XML_Char* name)
643 {
644  DEBTRACE( _data );
645  _father->addData(_data);
646  string elem = (char *) name;
647  //if (elem == "value" || elem == "data" || elem == "array")
648  stateParser::onEnd(name);
649  //else YASSERT(0); //DEBTRACE("valueParser::onEnd " << elem);
650 }
651 
652 // ----------------------------------------------------------------------------
653 
654 void arrayParser::init(const xmlChar** p, xmlParserBase* father)
655 {
656  DEBTRACE("arrayParser::init()");
657  _state = XMLINVALUE;
658  _father = father;
659  _stackState.push(_state);
660  if (p) getAttributes(p);
661 }
662 
663 
664 void arrayParser::onStart (const XML_Char* elem, const xmlChar** p)
665 {
666  string element(elem);
667  DEBTRACE("array type " << element);
668  stateParser *parser = 0;
669  if (element == "data") parser = new dataParser();
670  else
671  {
672  _what = "expected data, got <" + element + ">";
673  _state = XMLFATALERROR;
674  stopParse(_what);
675  }
676  if (parser)
677  {
678  _stackParser.push(parser);
679  XML_SetUserData(_xmlParser, parser);
680  parser->init(p, this);
681  }
682 }
683 
684 void arrayParser::addData(std::string value)
685 {
686  string val = "<array>" + value + "</array>";
687  _data = val;
688 }
689 
690 
691 void arrayParser::onEnd (const XML_Char* name)
692 {
693  // cerr << "arrayParser::onEnd " << name << endl;
694  // cerr << _data << endl;
695  _father->addData(_data);
696  stateParser::onEnd(name);
697 }
698 
699 // ----------------------------------------------------------------------------
700 
701 void dataParser::init(const xmlChar** p, xmlParserBase* father)
702 {
703  DEBTRACE("dataParser::init()");
704  _state = XMLINVALUE;
705  _father = father;
706  _stackState.push(_state);
707  if (p) getAttributes(p);
708 }
709 
710 
711 void dataParser::onStart (const XML_Char* elem, const xmlChar** p)
712 {
713  string element(elem);
714  DEBTRACE("data type " << element );
715  stateParser *parser = 0;
716  if (element == "value") parser = new valueParser();
717  else
718  {
719  _what = "expected value, got <" + element + ">";
720  _state = XMLFATALERROR;
721  stopParse(_what);
722  }
723  if (parser)
724  {
725  _stackParser.push(parser);
726  XML_SetUserData(_xmlParser, parser);
727  parser->init(p, this);
728  }
729 }
730 
731 void dataParser::addData(std::string value)
732 {
733  _dataList.push_back(value);
734 }
735 
736 void dataParser::onEnd (const XML_Char* name)
737 {
738  // cerr << "dataParser::onEnd " << name << endl;
739  string val = "<data>";
740  while (!_dataList.empty())
741  {
742  val += _dataList.front();
743  _dataList.pop_front();
744  }
745  val += "</data>";
746  // cerr << val << endl;
747  _father->addData(val);
748  stateParser::onEnd(name);
749 }
750 
751 // ----------------------------------------------------------------------------
752 
753 void simpleTypeParser::init(const xmlChar** p, xmlParserBase* father)
754 {
755  DEBTRACE("simpleTypeParser::init()");
756  _state = XMLINVALUE;
757  _father = father;
758  _stackState.push(_state);
759  if (p) getAttributes(p);
760 }
761 
762 void simpleTypeParser::onStart (const XML_Char* elem, const xmlChar** p)
763 {
764  string element(elem);
765  _what = "expected nothing, got <" + element + ">";
766  _state = XMLFATALERROR;
767  stopParse(_what);
768 }
769 
770 void simpleTypeParser::onEnd (const XML_Char* name)
771 {
772  string val = string("<") + (char*) name + ">" + _data + "</" + (char*) name +">";
773  DEBTRACE( val );
774  _father->addData(val);
775  stateParser::onEnd(name);
776 }
777 
778 void simpleTypeParser::charData(std::string data)
779 {
780  _data = _data + data;
781 }
782 
783 // ----------------------------------------------------------------------------
784 
785 void loopPortParser::init(const xmlChar** p, xmlParserBase* father)
786 {
787  DEBTRACE("loopPortParser::init()");
788  //_state = XMLINPORT;
789  _father = father;
790  _stackState.push(_state);
791  _ids.clear();
792  _sampleData.clear();
793  if (p) getAttributes(p);
794 }
795 
796 void loopPortParser::onStart(const XML_Char* elem, const xmlChar** p)
797 {
798  DEBTRACE("loopPortParser::onStart" << elem);
799  string element(elem);
800  stateParser *parser = 0;
801  if (element == "name") parser = new attrParser();
802  else if (element == "sample") parser = new sampleParser(this);
803  else
804  {
805  _what = "expected name or sample, got <" + element + ">";
806  _state = XMLFATALERROR;
807  stopParse(_what);
808  }
809  if (parser)
810  {
811  _stackParser.push(parser);
812  XML_SetUserData(_xmlParser, parser);
813  parser->init(p, this);
814  }
815 }
816 
817 void loopPortParser::onEnd(const XML_Char* name)
818 {
819  stateParser::onEnd(name);
820 }
821 
822 void loopPortParser::charData(std::string data)
823 {
824 }
825 
826 void loopPortParser::addSample(int index, const std::string data)
827 {
828  _ids.push_back(index);
829  _sampleData.push_back(data);
830 }
831 
832 unsigned int loopPortParser::getNbSamples()const
833 {
834  return _ids.size();
835 }
836 
837 unsigned int loopPortParser::getSampleId(unsigned int i)const
838 {
839  return _ids[i];
840 }
841 
842 const std::string& loopPortParser::getSampleData(unsigned int i)const
843 {
844  return _sampleData[i];
845 }
846 
847 const std::string& loopPortParser::getPortName()const
848 {
849  return _mapAttrib.at("name");
850 }
851 
852 // ----------------------------------------------------------------------------
853 
854 sampleParser::sampleParser(loopPortParser* father)
855 : stateParser(),
856  _sampleFather(father)
857 {
858 }
859 
860 void sampleParser::init(const xmlChar** p, xmlParserBase* father)
861 {
862  DEBTRACE("sampleParser::init()");
863  //_state = XMLINPORT;
864  _father = father;
865  _stackState.push(_state);
866  if (p) getAttributes(p);
867 }
868 
869 void sampleParser::onStart(const XML_Char* elem, const xmlChar** p)
870 {
871  DEBTRACE("sampleParser::onStart" << elem);
872  string element(elem);
873  stateParser *parser = 0;
874  if (element == "index") parser = new attrParser();
875  else if (element == "value") parser = new valueParser();
876  else
877  {
878  _what = "expected index or value, got <" + element + ">";
879  _state = XMLFATALERROR;
880  stopParse(_what);
881  }
882  if (parser)
883  {
884  _stackParser.push(parser);
885  XML_SetUserData(_xmlParser, parser);
886  parser->init(p, this);
887  }
888 }
889 
890 void sampleParser::onEnd(const XML_Char* name)
891 {
892  if (_mapAttrib.find("index") == _mapAttrib.end())
893  {
894  _what = "no attribute index in sample ";
895  _state = XMLFATALERROR;
896  stopParse(_what);
897  }
898  int index = atoi(_mapAttrib["index"].c_str());
899  _sampleFather->addSample(index, _data);
900  stateParser::onEnd(name);
901 }
902 
903 void sampleParser::charData(std::string data)
904 {
905  _data = _data + data;
906 }
907 
908 // ----------------------------------------------------------------------------
909 
910 stateLoader::stateLoader(xmlParserBase* parser,
911  YACS::ENGINE::Proc* p) : xmlReader(parser)
912 {
913  _runtime = getRuntime();
914  _p = p;
915 }
916 
917 void stateLoader::parse(std::string xmlState)
918 {
919  DEBTRACE("stateLoader::parse");
920  stateParser *parser = dynamic_cast<stateParser*> (_rootParser);
921  parser->setProc(_p);
922  parser->setRuntime(_runtime);
923 
924  xmlReader::parse(xmlState);
925 
926  DEBTRACE(parser->_state);
927  switch (parser->_state)
928  {
929  case XMLNOCONTEXT:
930  case XMLDONE:
931  {
932  DEBTRACE("parse OK");
933  break;
934  }
935  case XMLFATALERROR:
936  {
937  string what = "Abort Parse: " + parser->_what;
938  throw Exception(what);
939  break;
940  }
941  default:
942  {
943  string what = "Abort Parse: unknown execution problem";
944  throw Exception(what);
945  break;
946  }
947  }
948 }
949 
950 void YACS::ENGINE::loadState(YACS::ENGINE::Proc *p,const std::string& xmlStateFile)
951 {
952  DEBTRACE("YACS::ENGINE::loadState");
953  p->init();
954  p->exUpdateState();
955  stateParser* rootParser = new stateParser();
956  stateLoader myStateLoader(rootParser, p);
957  myStateLoader.parse(xmlStateFile);
958 }