-
+// Copyright (C) 2006-2008 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
#include "LoadState.hxx"
#include "Proc.hxx"
#include "Node.hxx"
Node *node =0;
string nodeName = it->first;
DEBTRACE("nodeName = " << nodeName);
- if ( _p->nodeMap.find(nodeName) != _p->nodeMap.end() )
- node = _p->getChildByName(nodeName);
+ if(_p->getName() == nodeName)
+ node = _p;
else
- {
- assert(_p->getName() == nodeName);
- node = _p;
- }
+ node = _p->getChildByName(nodeName);
+
InGate* inGate = node->getInGate();
list<OutGate*> backlinks = inGate->getBackLinks();
for (list<OutGate*>::iterator io = backlinks.begin(); io != backlinks.end(); io++)
void nodeParser::init(const xmlChar** p, xmlParserBase* father)
{
- //DEBTRACE("nodeParser::init()");
+ DEBTRACE("nodeParser::init()");
_state = XMLINNODE;
_father = father;
_stackState.push(_state);
void nodeParser::onStart (const XML_Char* elem, const xmlChar** p)
{
+ DEBTRACE("nodeParser::onStart" << elem);
string element(elem);
stateParser *parser = 0;
if (element == "inputPort") parser = new portParser();
string nodeName = _mapAttrib["name"];
string nodeType = _mapAttrib["type"];
string nodeState = _mapAttrib["state"];
- cerr << "nodeName: " << nodeName \
- << " nodeType: " << nodeType \
- << " nodeState: " << nodeState << endl;
+ DEBTRACE( "nodeName: " << nodeName << " nodeType: " << nodeType << " nodeState: " << nodeState );
// for (std::map< std::string, Node * >::iterator it=_p->nodeMap.begin(); it != _p->nodeMap.end(); it++)
// cerr << "nodeMap: " << it->first << endl;
_nodeStates[nodeName] = _nodeStateValue[nodeState];
Node *node =0;
- if ( _p->nodeMap.find(nodeName) != _p->nodeMap.end() )
+ if(_p->getName() == nodeName)
+ node=_p;
+ else
node = _p->getChildByName(nodeName);
- else
- {
- assert(_p->getName() == nodeName);
- node = _p;
- }
+
assert(_nodeStateValue.find(nodeState) != _nodeStateValue.end());
YACS::ENGINE::StateLoader(node, _nodeStateValue[nodeState]);
void attrParser::init(const xmlChar** p, xmlParserBase* father)
{
- //DEBTRACE("attrParser::init()");
+ DEBTRACE("attrParser::init()");
//_state = XMLINNODE;
_father = father;
_stackState.push(_state); // keep current state
void portParser::init(const xmlChar** p, xmlParserBase* father)
{
- // DEBTRACE("portParser::init()");
+ DEBTRACE("portParser::init()");
_state = XMLINPORT;
_father = father;
assert( dynamic_cast<nodeParser*> (father));
void portParser::onStart (const XML_Char* elem, const xmlChar** p)
{
+ DEBTRACE("portParser::onStart" << elem);
string element(elem);
stateParser *parser = 0;
if (element == "name") parser = new attrParser();
void portParser::onEnd (const XML_Char* name)
{
- cerr << "portName: " << _mapAttrib["name"] << endl;
- cerr << "value: " << _data << endl;
+ DEBTRACE("portName: " << _mapAttrib["name"] << "value: " << _data );
string nodeName = _father->getAttribute("name");
string nodeType = _father->getAttribute("type");
Node *node = _p->getChildByName(nodeName);
ElementaryNode* eNode = dynamic_cast<ElementaryNode*>(node);
assert(eNode);
InputPort *port = eNode->getInputPort(_mapAttrib["name"]);
- port->edInit("XML",_data.c_str());
+ if(_data != "")
+ port->edInit("XML",_data.c_str());
}
else if (nodeType == "forLoop")
{
void valueParser::init(const xmlChar** p, xmlParserBase* father)
{
- // DEBTRACE("valueParser::init()");
+ DEBTRACE("valueParser::init()");
_state = XMLINVALUE;
_father = father;
_stackState.push(_state);
void valueParser::onStart (const XML_Char* elem, const xmlChar** p)
{
string element(elem);
- // cerr << "value type " << element << endl;
+ DEBTRACE("value type " << element );
stateParser *parser = 0;
if (element == "data") parser = new dataParser();
else if (element == "array") parser = new arrayParser();
void valueParser::onEnd (const XML_Char* name)
{
- // cerr << _data << endl;
+ DEBTRACE( _data );
_father->addData(_data);
string elem = (char *) name;
//if (elem == "value" || elem == "data" || elem == "array")
void arrayParser::init(const xmlChar** p, xmlParserBase* father)
{
- // DEBTRACE("arrayParser::init()");
+ DEBTRACE("arrayParser::init()");
_state = XMLINVALUE;
_father = father;
_stackState.push(_state);
void arrayParser::onStart (const XML_Char* elem, const xmlChar** p)
{
string element(elem);
- // cerr << "array type " << element << endl;
+ DEBTRACE("array type " << element);
stateParser *parser = 0;
if (element == "data") parser = new dataParser();
else
void dataParser::init(const xmlChar** p, xmlParserBase* father)
{
- // DEBTRACE("dataParser::init()");
+ DEBTRACE("dataParser::init()");
_state = XMLINVALUE;
_father = father;
_stackState.push(_state);
void dataParser::onStart (const XML_Char* elem, const xmlChar** p)
{
string element(elem);
- // cerr << "data type " << element << endl;
+ DEBTRACE("data type " << element );
stateParser *parser = 0;
if (element == "value") parser = new valueParser();
else
void simpleTypeParser::init(const xmlChar** p, xmlParserBase* father)
{
- // DEBTRACE("simpleTypeParser::init()");
+ DEBTRACE("simpleTypeParser::init()");
_state = XMLINVALUE;
_father = father;
_stackState.push(_state);
void simpleTypeParser::onEnd (const XML_Char* name)
{
- // cerr << "simpleTypeParser::onEnd " << name << endl;
string val = string("<") + (char*) name + ">" + _data + "</" + (char*) name +">";
- // cerr << val << endl;
+ DEBTRACE( val );
_father->addData(val);
stateParser::onEnd(name);
}
void simpleTypeParser::charData(std::string data)
{
- // cerr << "simple data " << data << endl;
- _data = data;
+ _data = _data + data;
}
void stateLoader::parse(std::string xmlState)
{
+ DEBTRACE("stateLoader::parse");
stateParser *parser = dynamic_cast<stateParser*> (_rootParser);
parser->setProc(_p);
parser->setRuntime(_runtime);
xmlReader::parse(xmlState);
- cerr << parser->_state << endl;
+ DEBTRACE(parser->_state);
switch (parser->_state)
{
case XMLNOCONTEXT:
case XMLDONE:
{
- cerr << "parse OK" << endl;
+ DEBTRACE("parse OK");
break;
}
case XMLFATALERROR:
}
}
+void YACS::ENGINE::loadState(YACS::ENGINE::Proc *p,const std::string& xmlStateFile)
+{
+ DEBTRACE("YACS::ENGINE::loadState");
+ p->init();
+ p->exUpdateState();
+ stateParser* rootParser = new stateParser();
+ stateLoader myStateLoader(rootParser, p);
+ myStateLoader.parse(xmlStateFile);
+}
