#include <LoadState.hxx>

Inheritance diagram for YACS::ENGINE::nodeParser:

Collaboration diagram for YACS::ENGINE::nodeParser:

[legend]

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

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

Public Member Functions inherited from xmlParserBase
void	setAttribute (std::string key, std::string value)

std::string	getAttribute (std::string key)

virtual void	addData (std::string value)

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

Public Attributes
std::string	_nodeName

std::string	_nodeState

Public Attributes inherited from xmlParserBase
std::map< std::string, int >	counts

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 Member Functions inherited from xmlParserBase
static void XMLCALL	start_document (void *userData)

static void XMLCALL	end_document (void *userData)

static void XMLCALL	start_element (void userData, const xmlChar name, const xmlChar **p)

static void XMLCALL	end_element (void userData, const xmlChar name)

static void XMLCALL	characters (void userData, const xmlChar ch, int len)

static void XMLCALL	comment (void userData, const xmlChar value)

static void XMLCALL	warning (void userData, const char fmt,...)

static void XMLCALL	error (void userData, const char fmt,...)

static void XMLCALL	fatal_error (void userData, const char fmt,...)

static void XMLCALL	cdata_block (void userData, const xmlChar value, int len)

static void	cleanGarbage ()

static int	getGarbageSize ()

static void	XML_SetUserData (_xmlParserCtxt ctxt, xmlParserBase parser)

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

static std::string	_what

Static Public Attributes inherited from xmlParserBase
static _xmlParserCtxt *	_xmlParser

static std::stack< xmlParserBase * >	_stackParser

Protected Member Functions inherited from YACS::ENGINE::stateParser
virtual void	onStart (const XML_Char elem, const xmlChar *p)

virtual void	onEnd (const XML_Char *name)

virtual void	charData (std::string data)

Protected Member Functions inherited from xmlParserBase
void	getAttributes (const xmlChar **p)

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

virtual void	onEnd (const XML_Char *name)

virtual void	charData (std::string data)

virtual void	incrCount (const XML_Char *elem)

virtual void	end ()

virtual void	stopParse (std::string what)

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

Static Protected Attributes inherited from xmlParserBase
static std::list< xmlParserBase * >	_garbage

Detailed Description

Definition at line 116 of file LoadState.hxx.

Member Function Documentation

◆ init()

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.

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

References xmlParserBase::_father, _loopSamples, YACS::ENGINE::stateParser::_stackState, YACS::ENGINE::stateParser::_state, DEBTRACE, xmlParserBase::getAttributes(), p, and YACS::ENGINE::XMLINNODE.

◆ onEnd()

void nodeParser::onEnd ( const XML_Char * name )

virtual

Reimplemented from YACS::ENGINE::stateParser.

Definition at line 277 of file LoadState.cxx.

{
  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);
}

References _loopSamples, xmlParserBase::_mapAttrib, YACS::ENGINE::stateParser::_nodeStates, YACS::ENGINE::stateParser::_nodeStateValue, YACS::ENGINE::stateParser::_p, YACS::ENGINE::stateParser::_state, YACS::ENGINE::stateParser::_what, YACS::ENGINE::ForEachLoopGen::assignPassedResults(), DEBTRACE, YACS::ENGINE::Switch::edGetConditionPort(), YACS::ENGINE::WhileLoop::edGetConditionPort(), YACS::ENGINE::ForLoop::edGetNbOfTimesInputPort(), YACS::ENGINE::InputPort::edInit(), YACS::ENGINE::ComposedNode::getChildByName(), YACS::ENGINE::ComposedNode::getName(), YACS::ENGINE::ForEachLoopGen::getOutputPortType(), yacsorb.CORBAEngineTest::i, YACS::ENGINE::NbDoneLoader(), YACS::ENGINE::SequenceAny::New(), YACS::ENGINE::stateParser::onEnd(), YACS::ENGINE::SequenceAny::setEltAtRank(), YACS::ENGINE::StateLoader(), xmlParserBase::stopParse(), YACS::ENGINE::XMLFATALERROR, xmlToAny(), and YASSERT.

◆ onStart()

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

virtual

Reimplemented from YACS::ENGINE::stateParser.

Definition at line 245 of file LoadState.cxx.

{
  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);
    }
}

References _loopSamples, xmlParserBase::_stackParser, YACS::ENGINE::stateParser::_state, YACS::ENGINE::stateParser::_what, xmlParserBase::_xmlParser, DEBTRACE, YACS::parser::init(), p, xmlParserBase::stopParse(), xmlParserBase::XML_SetUserData(), and YACS::ENGINE::XMLFATALERROR.

◆ xmlToAny()

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

Definition at line 442 of file LoadState.cxx.

{
  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;
}

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

Referenced by onEnd().

Member Data Documentation

◆ _loopSamples

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

private

Definition at line 126 of file LoadState.hxx.

Referenced by init(), onEnd(), and onStart().

◆ _nodeName

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

Definition at line 123 of file LoadState.hxx.

◆ _nodeState

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

◆ init()

◆ onEnd()

◆ onStart()

◆ xmlToAny()

Member Data Documentation

◆ _loopSamples

◆ _nodeName

◆ _nodeState