YACS::proctypeParser< T > Struct Template Reference

#include <procParsers.hxx>

Inheritance diagram for YACS::proctypeParser< T >:

Collaboration diagram for YACS::proctypeParser< T >:

Public Member Functions
	proctypeParser ()
void	onStart (const XML_Char *el, const XML_Char **attr)
virtual void	onEnd (const char *el, parser *child)
virtual void	buildAttr (const XML_Char **attr)
virtual void	pre ()
virtual void	name (const std::string &name)
virtual void	type (const mytype &t)
virtual void	sequence (ENGINE::TypeCode *const &t)
virtual void	objref (ENGINE::TypeCode *const &t)
virtual void	struct_ (ENGINE::TypeCode *const &t)
virtual void	componentinstance (const mycomponentinstance &t)
virtual void	container (const mycontainer &t)
T	post ()
Public Member Functions inherited from YACS::bloctypeParser< YACS::ENGINE::Proc * >
	bloctypeParser ()
void	name (const std::string &name)
void	name (const std::string &name)
virtual void	state (const std::string &name)
virtual void	property (const myprop &prop)
virtual void	inline_ (YACS::ENGINE::InlineNode *const &n)
virtual void	sinline (YACS::ENGINE::ServiceInlineNode *const &n)
virtual void	service (YACS::ENGINE::ServiceNode *const &n)
virtual void	remote (YACS::ENGINE::InlineNode *const &n)
virtual void	server (YACS::ENGINE::ServerNode *const &n)
virtual void	node (YACS::ENGINE::InlineNode *const &n)
virtual void	forloop (YACS::ENGINE::ForLoop *const &b)
virtual void	optimizer (YACS::ENGINE::OptimizerLoop *const &b)
virtual void	foreach (YACS::ENGINE::ForEachLoopGen *const &b)
virtual void	while_ (YACS::ENGINE::WhileLoop *const &b)
virtual void	switch_ (YACS::ENGINE::Switch *const &b)
virtual void	bloc (YACS::ENGINE::Bloc *const &b)
virtual void	control (const mycontrol &l)
virtual void	datalink (const mylink &l)
virtual void	stream (const mystream &l)
virtual void	parameter (const myparam &param)
virtual void	preset (ENGINE::DataNode *const &n)
virtual void	outnode (ENGINE::DataNode *const &n)
YACS::ENGINE::Proc *	post ()
Public Member Functions inherited from YACS::parser
	parser ()
virtual	~parser ()
virtual void	SetUserDataAndPush (parser *pp)
virtual void	charData (const XML_Char *s, int len)
virtual void	endParser ()
virtual void	init ()
virtual void	incrCount (const XML_Char *elem)
virtual void	checkOrder (std::string &el)
virtual void	maxcount (std::string name, int max, std::string &el)
virtual void	mincount (std::string name, int min)
virtual void	maxchoice (std::string *names, int max, std::string &el)
virtual void	minchoice (std::string *names, int min)
virtual void	required (const std::string &name, const XML_Char **attr)
std::stack< parser * > &	getStack ()
template<class T >
T	post ()
void	logError (const std::string &reason)

Static Public Attributes
static proctypeParser< T >	procParser
Static Public Attributes inherited from YACS::bloctypeParser< YACS::ENGINE::Proc * >
static bloctypeParser< YACS::ENGINE::Proc * >	blocParser
Static Public Attributes inherited from YACS::parser
static parser	main_parser
static std::stack< parser * >	_stackParser

Additional Inherited Members
Static Public Member Functions inherited from YACS::parser
static void XMLCALL	start_document (void *data)
static void XMLCALL	end_document (void *data)
static void XMLCALL	start_element (void *data, const xmlChar *name, const xmlChar **p)
static void XMLCALL	end_element (void *data, const xmlChar *name)
static void XMLCALL	characters (void *data, const xmlChar *ch, int len)
static void XMLCALL	comment (void *data, const xmlChar *value)
static void XMLCALL	cdata_block (void *data, const xmlChar *value, int len)
static void XMLCALL	warning (void *data, const char *fmt,...)
static void XMLCALL	error (void *data, const char *fmt,...)
static void XMLCALL	fatal_error (void *data, const char *fmt,...)
static void	XML_SetUserData (_xmlParserCtxt *ctxt, parser *par)
Public Attributes inherited from YACS::bloctypeParser< YACS::ENGINE::Proc * >
YACS::ENGINE::Proc *	_bloc
std::string	_state
std::vector< YACS::ENGINE::Bloc * >	_blocs
Public Attributes inherited from YACS::parser
std::string	_file
std::string	_content
std::map< std::string, int > *	_counts
std::map< std::string, int >	_orders
int	_orderState
int	_level
std::stack< std::map< std::string, int > * >	_stackCount
std::stack< int >	_stackOrder
std::map< std::string, parser * > *	_defaultParsersMap

Detailed Description

template<class T = YACS::ENGINE::Proc*>
struct YACS::proctypeParser< T >

Definition at line 39 of file procParsers.hxx.

Constructor & Destructor Documentation

proctypeParser()

template<class T = YACS::ENGINE::Proc*>

YACS::proctypeParser< T >::proctypeParser ( )

inline

Definition at line 44 of file procParsers.hxx.

                  :bloctypeParser<T>()
  {
    this->_orders["type"]=1;
    this->_orders["sequence"]=1;
    this->_orders["objref"]=1;
  }

References YACS::parser::_orders.

Member Function Documentation

buildAttr()

template<class T = YACS::ENGINE::Proc*>

virtual void YACS::proctypeParser< T >::buildAttr ( const XML_Char **  attr )

inlinevirtual

Reimplemented from YACS::bloctypeParser< YACS::ENGINE::Proc * >.

Definition at line 52 of file procParsers.hxx.

    {
          if (!attr)
                return;
      for (int i = 0; attr[i]; i += 2) 
        {
          if(std::string(attr[i]) == "state")
            this->state(attr[i+1]);
          if(std::string(attr[i]) == "name")
            name(attr[i+1]);
        }
    }

References yacsorb.CORBAEngineTest::i, YACS::proctypeParser< T >::name(), and YACS::bloctypeParser< YACS::ENGINE::Proc * >::state().

componentinstance()

template<class T = YACS::ENGINE::Proc*>

virtual void YACS::proctypeParser< T >::componentinstance ( const mycomponentinstance &  t )

inlinevirtual

Definition at line 99 of file procParsers.hxx.

    {
      DEBTRACE( "componentinstance: " << t._name );
      YACS::ENGINE::ComponentInstance* inst=currentProc->createComponentInstance(t._component,t._name,t._kind);
 
      // Set all properties for this component instance
      std::map<std::string, std::string>::const_iterator pt;
      for(pt=t._props.begin();pt!=t._props.end();pt++)
        inst->setProperty((*pt).first,(*pt).second);
 
      //associate a container to the component instance
      if(currentProc->containerMap.count(t._container) != 0)
        {
          inst->setContainer(currentProc->containerMap[t._container]);
        }
      else if(t._container == "")
        {
          if(currentProc->containerMap.count("DefaultContainer") != 0)
          {
            //a default container is defined : use it if supported
            try
            {
              currentProc->containerMap["DefaultContainer"]->checkCapabilityToDealWith(inst);
              inst->setContainer(currentProc->containerMap["DefaultContainer"]);
            }
            catch(YACS::Exception){}
          }
        }
      else
        {
          std::cerr << "WARNING: Unknown container " << t._container << " ignored" << std::endl;
        }
 
      inst->decrRef();
    }

References YACS::ENGINE::Proc::containerMap, YACS::ENGINE::Proc::createComponentInstance(), currentProc, DEBTRACE, YACS::ENGINE::RefCounter::decrRef(), YACS::ENGINE::ComponentInstance::setContainer(), YACS::ENGINE::PropertyInterface::setProperty(), and gui.Appli::t.

container()

template<class T = YACS::ENGINE::Proc*>

virtual void YACS::proctypeParser< T >::container ( const mycontainer &  t )

inlinevirtual

Definition at line 135 of file procParsers.hxx.

    {
      DEBTRACE( "container_set: " << t._name )             
      std::vector<machine>::const_iterator iter;
      for(iter=t._machs.begin();iter!=t._machs.end();iter++)
        {
          DEBTRACE( "machine name: " << (*iter)._name )             
        }
 
      if(currentProc->containerMap.count(t._name) != 0 && t._name != "DefaultContainer")
        {
          std::cerr << "Warning: container " << t._name << " already defined. It will be ignored" << std::endl;
        }
      else
        {
          // Set all properties for this container
          std::string kindOfContainer;
          std::map<std::string, std::string>::const_iterator pt(t._props.find(std::string(ENGINE::Container::KIND_ENTRY)));
          if(pt!=t._props.end())
            kindOfContainer=pt->second;
          YACS::ENGINE::Container *cont(currentProc->createContainer(t._name,kindOfContainer));
          for(pt=t._props.begin();pt!=t._props.end();pt++)
            if((*pt).second!=ENGINE::Container::KIND_ENTRY)
              cont->setProperty((*pt).first,(*pt).second);
          cont->decrRef();
        }
    }

References YACS::ENGINE::Proc::containerMap, YACS::ENGINE::Proc::createContainer(), currentProc, DEBTRACE, YACS::ENGINE::RefCounter::decrRef(), YACS::ENGINE::Container::KIND_ENTRY, YACS::ENGINE::Container::setProperty(), and gui.Appli::t.

name()

template<class T = YACS::ENGINE::Proc*>

virtual void YACS::proctypeParser< T >::name ( const std::string &  name )

inlinevirtual

Definition at line 72 of file procParsers.hxx.

    {
      currentProc->setName(name);
    }

References currentProc, and YACS::ENGINE::Proc::setName().

Referenced by YACS::proctypeParser< T >::buildAttr(), and YACS::proctypeParser< T >::pre().

objref()

template<class T = YACS::ENGINE::Proc*>

virtual void YACS::proctypeParser< T >::objref ( ENGINE::TypeCode *const &  t )

inlinevirtual

Definition at line 88 of file procParsers.hxx.

    {
        DEBTRACE( "objref_set" );
        t->decrRef();
    }

References DEBTRACE, and gui.Appli::t.

onEnd()

template<class T >

void YACS::proctypeParser< T >::onEnd ( const char *  el, parser *  child  )

virtual

Reimplemented from YACS::bloctypeParser< YACS::ENGINE::Proc * >.

Definition at line 232 of file procParsers.hxx.

    {
      DEBTRACE( "proctypeParser::onEnd: " << el )
      std::string element(el);
      if(element == "property")this->property(((propertytypeParser*)child)->post());
      else if(element == "type")type(((typetypeParser*)child)->post());
      else if(element == "sequence")sequence(((seqtypeParser*)child)->post());
      else if(element == "objref")objref(((objtypeParser*)child)->post());
      else if(element == "struct")struct_(((structtypeParser*)child)->post());
      else if(element == "container")container(((containertypeParser*)child)->post());
      else if(element == "componentinstance")componentinstance(((componentinstancetypeParser*)child)->post());
 
      else if(element == "inline")this->inline_(((inlinetypeParser<>*)child)->post());
      else if(element == "sinline")this->sinline(((sinlinetypeParser<>*)child)->post());
      else if(element == "service")this->service(((servicetypeParser<>*)child)->post());
      else if(element == "server")this->server(((servertypeParser<>*)child)->post());
      else if(element == "remote")this->remote(((remotetypeParser<>*)child)->post());
      else if(element == "node")this->node(((nodetypeParser<>*)child)->post());
      else if(element == "datanode")this->preset(((presettypeParser<>*)child)->post());
      else if(element == "outnode")this->outnode(((outnodetypeParser<>*)child)->post());
 
      else if(element == "bloc")this->bloc(((bloctypeParser<>*)child)->post());
      else if(element == "forloop")this->forloop(((forlooptypeParser<>*)child)->post());
      else if(element == "foreach")this->foreach(((foreachlooptypeParser<ENGINE::ForEachLoop *>*)child)->post());
      else if(element == "foreachdyn")this->foreach(((foreachlooptypeParser<ENGINE::ForEachLoopDyn *>*)child)->post());
      else if(element == "optimizer")this->optimizer(((optimizerlooptypeParser<>*)child)->post());
      else if(element == "while")this->while_(((whilelooptypeParser<>*)child)->post());
      else if(element == "switch")this->switch_(((switchtypeParser*)child)->post());
 
      else if(element == "control") this->control(((controltypeParser<>*)child)->post());
      else if(element == "datalink") this->datalink(((linktypeParser<>*)child)->post());
      else if(element == "stream") this->stream(((streamtypeParser<>*)child)->post());
      else if(element == "parameter") this->parameter(((parametertypeParser*)child)->post());
    }

References DEBTRACE.

onStart()

template<class T >

void YACS::proctypeParser< T >::onStart ( const XML_Char *  el, const XML_Char **  attr  )

virtual

Reimplemented from YACS::bloctypeParser< YACS::ENGINE::Proc * >.

Definition at line 173 of file procParsers.hxx.

  {
    DEBTRACE( "proctypeParser::onStart: " << el )
    std::string element(el);
    this->checkOrder(element);
    parser* pp=&parser::main_parser;
    if(element == "property")pp=&propertytypeParser::propertyParser;
    else if(element == "type")pp=&typetypeParser::typeParser;
    else if(element == "sequence")pp=&seqtypeParser::seqParser;
    else if(element == "objref")pp=&objtypeParser::objParser;
    else if(element == "struct")pp=&structtypeParser::structParser;
    else if(element == "container")pp=&containertypeParser::containerParser;
    else if(element == "componentinstance")pp=&componentinstancetypeParser::componentinstanceParser;
 
    else if(element == "inline")pp=&inlinetypeParser<>::inlineParser;
    else if(element == "sinline")pp=&sinlinetypeParser<>::sinlineParser;
    else if(element == "service")pp=&servicetypeParser<>::serviceParser;
    else if(element == "server")pp=&servertypeParser<>::serverParser;
    else if(element == "remote")pp=&remotetypeParser<>::remoteParser;
    else if(element == "node")pp=&nodetypeParser<>::nodeParser;
    else if(element == "datanode")pp=&presettypeParser<>::presetParser;
    else if(element == "outnode")pp=&outnodetypeParser<>::outnodeParser;
 
    else if(element == "bloc")pp=&bloctypeParser<>::blocParser;
    else if(element == "forloop")pp=&forlooptypeParser<>::forloopParser;
    else if(element == "foreach")pp=&foreachlooptypeParser<ENGINE::ForEachLoop *>::foreachloopParser;
    else if(element == "foreachdyn")pp=&foreachlooptypeParser<ENGINE::ForEachLoopDyn *>::foreachloopParser;
    else if(element == "optimizer")pp=&optimizerlooptypeParser<>::optimizerloopParser;
    else if(element == "while")pp=&whilelooptypeParser<>::whileloopParser;
    else if(element == "switch")pp=&switchtypeParser::switchParser;
 
    else if(element == "control")pp=&controltypeParser<>::controlParser;
    else if(element == "datalink")pp=&linktypeParser<>::linkParser;
    else if(element == "stream")pp=&streamtypeParser<>::streamParser;
    else if(element == "parameter")pp=&parametertypeParser::parameterParser;
    else
      {
        // OCC: san -- Allow external parsers for handling of unknown elements
        // and attributes. This capability is used by YACS GUI to read
        // graph presentation data
        if ( this->_defaultParsersMap )
          {
            if((this->_defaultParsersMap)->count(element) != 0)
              {
                pp=(*(this->_defaultParsersMap))[element];
              }
            else
              {
                std::cerr << "There is no parser for this element type. It will be ignored! " << element << std::endl;
              }
          }
      }
    this->SetUserDataAndPush(pp);
    pp->init();
    pp->pre();
    pp->buildAttr(attr);
  }

References YACS::parser::buildAttr(), YACS::componentinstancetypeParser::componentinstanceParser, YACS::containertypeParser::containerParser, DEBTRACE, YACS::parser::init(), YACS::parser::main_parser, YACS::objtypeParser::objParser, YACS::parametertypeParser::parameterParser, YACS::parser::pre(), YACS::propertytypeParser::propertyParser, YACS::seqtypeParser::seqParser, YACS::structtypeParser::structParser, YACS::switchtypeParser::switchParser, and YACS::typetypeParser::typeParser.

post()

template<class T = YACS::ENGINE::Proc*>

T YACS::proctypeParser< T >::post ( )

inline

Definition at line 163 of file procParsers.hxx.

{ return this->_bloc; }

References YACS::bloctypeParser< YACS::ENGINE::Proc * >::_bloc.

pre()

template<class T = YACS::ENGINE::Proc*>

virtual void YACS::proctypeParser< T >::pre ( )

inlinevirtual

Reimplemented from YACS::parser.

Definition at line 64 of file procParsers.hxx.

    {
        std::string name("proc");
        currentProc=theRuntime->createProc(name);
        this->_bloc=currentProc;
        currentProc->names.push_back("");
    }

References YACS::bloctypeParser< YACS::ENGINE::Proc * >::_bloc, YACS::ENGINE::Runtime::createProc(), currentProc, YACS::proctypeParser< T >::name(), YACS::ENGINE::Proc::names, and theRuntime.

sequence()

template<class T = YACS::ENGINE::Proc*>

virtual void YACS::proctypeParser< T >::sequence ( ENGINE::TypeCode *const &  t )

inlinevirtual

Definition at line 83 of file procParsers.hxx.

    {
        DEBTRACE( "sequence_set" );
        t->decrRef();
    }

References DEBTRACE, and gui.Appli::t.

struct_()

template<class T = YACS::ENGINE::Proc*>

virtual void YACS::proctypeParser< T >::struct_ ( ENGINE::TypeCode *const &  t )

inlinevirtual

Definition at line 93 of file procParsers.hxx.

    {
        DEBTRACE( "struct_set" );
        t->decrRef();
    }

References DEBTRACE, and gui.Appli::t.

type()

template<class T = YACS::ENGINE::Proc*>

virtual void YACS::proctypeParser< T >::type ( const mytype &  t )

inlinevirtual

Definition at line 77 of file procParsers.hxx.

    {
        DEBTRACE( "type_set" );
        YACS::ENGINE::TypeCode* tt=currentProc->createType(t._name,t._kind);
        tt->decrRef();
    }

References YACS::ENGINE::Proc::createType(), currentProc, DEBTRACE, YACS::ENGINE::RefCounter::decrRef(), and gui.Appli::t.

Member Data Documentation

procParser

template<class T >

proctypeParser< T > YACS::proctypeParser< T >::procParser

static

Definition at line 42 of file procParsers.hxx.

---

The documentation for this struct was generated from the following file:

• src/yacsloader/procParsers.hxx