#include <LoadState.hxx>

Inheritance diagram for YACS::ENGINE::nodeParser:

Collaboration diagram for YACS::ENGINE::nodeParser:

Public Member Functions
virtual void	init (const xmlChar *p, xmlParserBase father=0)

virtual void	onStart (const XML_Char elem, const xmlChar *p)

virtual void	onEnd (const XML_Char *name)

Any *	xmlToAny (const std::string &data, const TypeCode *tc) const

Public Attributes
std::string	_nodeName

std::string	_nodeState

Private Attributes
std::list< loopPortParser * >	_loopSamples

Additional Inherited Members
Static Public Member Functions inherited from YACS::ENGINE::stateParser
static void	setProc (Proc *p)

static void	setRuntime (Runtime *runtime)

Static Public Attributes inherited from YACS::ENGINE::stateParser
static XMLReadState	_state

static std::string	_what

Protected Member Functions inherited from YACS::ENGINE::stateParser
virtual void	charData (std::string data)

Protected Attributes inherited from xmlParserBase
std::map< std::string, std::string >	_mapAttrib

std::string	_data

xmlParserBase *	_father

Static Protected Attributes inherited from YACS::ENGINE::stateParser
static std::stack< XMLReadState >	_stackState

static Proc *	_p

static Runtime *	_runtime

static std::map< std::string, YACS::StatesForNode >	_nodeStateValue

static std::map< std::string, YACS::StatesForNode >	_nodeStates

Detailed Description

Definition at line 116 of file LoadState.hxx.

Member Function Documentation

void nodeParser::init	(	const xmlChar **	p,
		xmlParserBase *	father = `0`
	)

virtual

all parsers must know their father parser (father tag), in order to set values or attributes in father.

Reimplemented from YACS::ENGINE::stateParser.

Definition at line 234 of file LoadState.cxx.

References DEBTRACE, and YACS::ENGINE::XMLINNODE.

 {
   DEBTRACE("nodeParser::init()");
   _loopSamples.clear();
   _state = XMLINNODE;
   _father = father;
   _stackState.push(_state);
   if (p) getAttributes(p);
 }

void nodeParser::onEnd ( const XML_Char * name )

virtual

Reimplemented from YACS::ENGINE::stateParser.

Definition at line 277 of file LoadState.cxx.

References YACS::ENGINE::ForEachLoop::assignPassedResults(), DEBTRACE, YACS::ENGINE::WhileLoop::edGetConditionPort(), YACS::ENGINE::Switch::edGetConditionPort(), YACS::ENGINE::ForLoop::edGetNbOfTimesInputPort(), YACS::ENGINE::InputPort::edInit(), YACS::ENGINE::Node::getChildByName(), YACS::ENGINE::ForEachLoop::getOutputPortType(), CORBAEngineTest::i, YACS::ENGINE::NbDoneLoader(), YACS::ENGINE::SequenceAny::New(), YACS::ENGINE::stateParser::onEnd(), YACS::ENGINE::SequenceAny::setEltAtRank(), YACS::ENGINE::StateLoader(), YACS::ENGINE::XMLFATALERROR, and YASSERT.

 {
   string nodeName = _mapAttrib["name"];
   string nodeType = _mapAttrib["type"];
   string nodeState = _mapAttrib["state"];
   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->getName() == nodeName)
     node=_p;
   else 
     node = _p->getChildByName(nodeName);
 
   YASSERT(_nodeStateValue.find(nodeState) != _nodeStateValue.end());
   YACS::ENGINE::StateLoader(node, _nodeStateValue[nodeState]);
 
   if (nodeType == "forLoop")
     {
       if (_mapAttrib.find("nsteps") == _mapAttrib.end())
         {
           _what = "no attribute nsteps in forLoop " + _mapAttrib["name"];
           _state = XMLFATALERROR;
           stopParse(_what);
         }
       int nsteps =  atoi(_mapAttrib["nsteps"].c_str());
 
       if (_mapAttrib.find("nbdone") == _mapAttrib.end())
         {
           _what = "no attribute nbdone in forLoop " + _mapAttrib["name"];
           _state = XMLFATALERROR;
           stopParse(_what);
         }
       int nbdone =  atoi(_mapAttrib["nbdone"].c_str());
       DEBTRACE("nsteps = " << nsteps << ", nbdone = " << nbdone);
 
       ForLoop* loop = dynamic_cast<ForLoop*>(node);
       if (!loop)
         {
           _what = "node is not a ForLoop: " + _mapAttrib["name"];
           _state = XMLFATALERROR;
           stopParse(_what);
         }
       loop->edGetNbOfTimesInputPort()->edInit(nsteps);
       YACS::ENGINE::NbDoneLoader(loop, nbdone);
     }
 
   else if (nodeType == "whileLoop")
     {
       if (_mapAttrib.find("nbdone") == _mapAttrib.end())
         {
           _what = "no attribute nbdone in forLoop " + _mapAttrib["name"];
           _state = XMLFATALERROR;
           stopParse(_what);
         }
       int nbdone =  atoi(_mapAttrib["nbdone"].c_str());
 
       if (_mapAttrib.find("condition") == _mapAttrib.end())
         {
           _what = "no attribute condition in forLoop " + _mapAttrib["name"];
           _state = XMLFATALERROR;
           stopParse(_what);
         }
       bool condition =  atoi(_mapAttrib["condition"].c_str());
       DEBTRACE("condition = " << condition << ", nbdone = " << nbdone);
 
       WhileLoop* loop = dynamic_cast<WhileLoop*>(node);
       if (!loop)
         {
           _what = "node is not a WhileLoop: " + _mapAttrib["name"];
           _state = XMLFATALERROR;
           stopParse(_what);
         }
       loop->edGetConditionPort()->edInit(condition);
       YACS::ENGINE::NbDoneLoader(loop, nbdone);
     }
 
   else if (nodeType == "switch")
     {
       if (_mapAttrib.find("condition") == _mapAttrib.end())
         {
           _what = "no attribute condition in switch " + _mapAttrib["name"];
           _state = XMLFATALERROR;
           stopParse(_what);
         }
       int condition =  atoi(_mapAttrib["condition"].c_str());
       DEBTRACE("condition = " << condition);
 
       Switch* mySwitch = dynamic_cast<Switch*>(node);
       if (!mySwitch)
         {
           _what = "node is not a Switch: " + _mapAttrib["name"];
           _state = XMLFATALERROR;
           stopParse(_what);
         }
       mySwitch->edGetConditionPort()->edInit(condition);
     }
   else if (nodeType == "forEachLoop")
   {
     ForEachLoop* feNode = dynamic_cast<ForEachLoop*>(node);
     if(!feNode)
     {
       _what = "node is not a ForEachLoop: " + _mapAttrib["name"];
       _state = XMLFATALERROR;
       stopParse(_what);
     }
     else
     {
       std::vector<unsigned int> passedIds;
       std::vector<SequenceAny *> passedOutputs;
       std::vector<std::string> nameOfOutputs;
       bool firstPort = true;
       std::list<loopPortParser*>::const_iterator itPort;
       for(itPort=_loopSamples.begin(); itPort!=_loopSamples.end(); itPort++)
       {
         const std::string& portName =(*itPort)->getPortName();
         nameOfOutputs.push_back(portName);
         const YACS::ENGINE::TypeCode* tc = feNode->getOutputPortType(portName);
         if(!tc)
         {
           _what = "Impossible to find the type of the port " + portName;
           _state = XMLFATALERROR;
           stopParse(_what);
           return;
         }
         unsigned int nbSamples = (*itPort)->getNbSamples();
         SequenceAny* seqValues = SequenceAny::New(tc, nbSamples);
         passedOutputs.push_back(seqValues);
         for(unsigned int i = 0; i < nbSamples; i++)
         {
           unsigned int sampleId = (*itPort)->getSampleId(i);
           const std::string& sampleData = (*itPort)->getSampleData(i);
           Any* value = xmlToAny(sampleData, tc);
           if(firstPort)
           {
             passedIds.push_back(sampleId);
             seqValues->setEltAtRank(i, value);
           }
           else
           {
             unsigned int pos = 0;
             while(pos < passedIds.size() && sampleId != passedIds[pos])
               pos++;
             if(pos < passedIds.size())
               seqValues->setEltAtRank(pos, value);
             else
             {
               _what = "Inconsistent sample id in foreach node " + _mapAttrib["name"];
               _state = XMLFATALERROR;
               stopParse(_what);
               itPort=_loopSamples.end();
               return;
             }
           }
         }
         firstPort = false;
       }
       feNode->assignPassedResults(passedIds, passedOutputs, nameOfOutputs);
     }
   }
 
   stateParser::onEnd(name);
 }

void nodeParser::onStart	(	const XML_Char *	elem,
		const xmlChar **	p
	)

virtual

Reimplemented from YACS::ENGINE::stateParser.

Definition at line 245 of file LoadState.cxx.

References DEBTRACE, YACS::ENGINE::stateParser::init(), and YACS::ENGINE::XMLFATALERROR.

 {
   DEBTRACE("nodeParser::onStart" << elem);
   string element(elem);
   stateParser *parser = 0;
   if (element == "inputPort")      parser = new portParser();
   else if (element == "name")      parser = new attrParser();
   else if (element == "state")     parser = new attrParser();
   else if (element == "nsteps")    parser = new attrParser();
   else if (element == "nbdone")    parser = new attrParser();
   else if (element == "condition") parser = new attrParser();
   else if (element == "outputPort") parser = new outputParser();
   else if (element == "loopOutputPort")
   {
     loopPortParser* sparser = new loopPortParser();
     _loopSamples.push_back(sparser);
     parser = sparser;
   }
   else
     { 
       _what = "expected name, state or inputPort, got <" + element + ">";
       _state = XMLFATALERROR;
       stopParse(_what);
     }
   if (parser)
     {
       _stackParser.push(parser);
       XML_SetUserData(_xmlParser, parser);
       parser->init(p, this);
     }
 }

Any * nodeParser::xmlToAny	(	const std::string &	data,
		const TypeCode *	tc
	)		const

Definition at line 442 of file LoadState.cxx.

References YACS::ENGINE::convertXmlNeutral(), and doc.

 {
   xmlDocPtr doc;
   xmlNodePtr cur;
   //YACS::ENGINE::Any *ob=YACS::ENGINE::AtomAny::New(0);
   YACS::ENGINE::Any *ob=NULL;
   {
     doc = xmlParseMemory(data.c_str(), data.length());
     if (doc == NULL )
       {
         stringstream msg;
         msg << "Problem in conversion: XML Document not parsed successfully ";
         msg << " (" << __FILE__ << ":" << __LINE__ << ")";
         throw ConversionException(msg.str());
       }
     cur = xmlDocGetRootElement(doc);
     if (cur == NULL)
       {
         xmlFreeDoc(doc);
         stringstream msg;
         msg << "Problem in conversion: empty XML Document";
         msg << " (" << __FILE__ << ":" << __LINE__ << ")";
         throw ConversionException(msg.str());
       }
     while (cur != NULL)
       {
         if ((!xmlStrcmp(cur->name, (const xmlChar *)"value")))
           {
             ob=convertXmlNeutral(tc,doc,cur);
             break;
           }
         cur = cur->next;
       }
     xmlFreeDoc(doc);
     if(ob==NULL)
       {
         stringstream msg;
         msg << "Problem in conversion: incorrect XML value";
         msg << " (" << __FILE__ << ":" << __LINE__ << ")";
         throw ConversionException(msg.str());
       }
   }
   return ob;
 }

Member Data Documentation

std::list<loopPortParser*> YACS::ENGINE::nodeParser::_loopSamples

private

Definition at line 126 of file LoadState.hxx.

std::string YACS::ENGINE::nodeParser::_nodeName

Definition at line 123 of file LoadState.hxx.

std::string YACS::ENGINE::nodeParser::_nodeState

Definition at line 124 of file LoadState.hxx.

The documentation for this class was generated from the following files:

src/yacsloader/LoadState.hxx
src/yacsloader/LoadState.cxx

Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

Member Data Documentation