src/yacsloader/procParsers.hxx

   1 #ifndef _PROCPARSER_HXX_
   2 #define _PROCPARSER_HXX_
   3
   4 #include "blocParsers.hxx"
   5 #include "typeParsers.hxx"
   6 #include "containerParsers.hxx"
   7 #include "nodeParsers.hxx"
   8
   9 #include "Proc.hxx"
  10 #include "Container.hxx"
  11
  12 extern YACS::ENGINE::Proc* currentProc;
  13
  14 namespace YACS
  15 {
  16
  17 template <class T=YACS::ENGINE::Proc*>
  18 struct proctypeParser: bloctypeParser<T>
  19 {
  20
  21   static proctypeParser<T> procParser;
  22
  23   proctypeParser():bloctypeParser<T>()
  24   {
  25     this->_orders["type"]=1;
  26     this->_orders["sequence"]=1;
  27     this->_orders["objref"]=1;
  28   }
  29   void onStart(const XML_Char* el, const XML_Char** attr);
  30   virtual void onEnd(const char *el,parser* child);
  31   virtual void buildAttr(const XML_Char** attr)
  32     {
  33       for (int i = 0; attr[i]; i += 2)
  34         {
  35           if(std::string(attr[i]) == "state")this->state(attr[i+1]);
  36         }
  37     }
  38   virtual void pre ()
  39     {
  40         std::string name("proc");
  41         currentProc=theRuntime->createProc(name);
  42         this->_bloc=currentProc;
  43         currentProc->names.push_back("");
  44     }
  45   virtual void type (const mytype& t)
  46     {
  47         DEBTRACE( "type_set" )
  48         currentProc->typeMap[t._name]=currentProc->createType(t._name,t._kind);
  49     }
  50   virtual void sequence (ENGINE::TypeCode* const& t)
  51     {
  52         DEBTRACE( "sequence_set" )
  53         currentProc->typeMap[t->name()]=t;
  54     }
  55   virtual void objref (ENGINE::TypeCode* const& t)
  56     {
  57         DEBTRACE( "objref_set" )
  58         currentProc->typeMap[t->name()]=t;
  59     }
  60   virtual void struct_ (ENGINE::TypeCode* const& t)
  61     {
  62         DEBTRACE( "struct_set" )
  63         currentProc->typeMap[t->name()]=t;
  64     }
  65   virtual void container (const mycontainer& t)
  66     {
  67       DEBTRACE( "container_set: " << t._name )
  68       std::vector<machine>::const_iterator iter;
  69       for(iter=t._machs.begin();iter!=t._machs.end();iter++)
  70         {
  71           DEBTRACE( "machine name: " << (*iter)._name )
  72         }
  73
  74       if(currentProc->containerMap.count(t._name) == 0)
  75         {
  76           YACS::ENGINE::Container* cont=theRuntime->createContainer();
  77           cont->setName(t._name);
  78           // Set all properties for this container
  79           std::map<std::string, std::string>::const_iterator pt;
  80           for(pt=t._props.begin();pt!=t._props.end();pt++)
  81             cont->setProperty((*pt).first,(*pt).second);
  82           currentProc->containerMap[t._name]=cont;
  83         }
  84       else
  85         {
  86           std::cerr << "Warning: container " << t._name << " already defined. It will be ignored" << std::endl;
  87         }
  88     }
  89
  90   T post(){return this->_bloc;}
  91 };
  92
  93 template <class T> proctypeParser<T> proctypeParser<T>::procParser;
  94
  95 }
  96
  97 namespace YACS
  98 {
  99 template <class T>
 100 void proctypeParser<T>::onStart(const XML_Char* el, const XML_Char** attr)
 101   {
 102     DEBTRACE( "proctypeParser::onStart: " << el )
 103     std::string element(el);
 104     this->checkOrder(element);
 105     parser* pp=&parser::main_parser;
 106     if(element == "property")pp=&propertytypeParser::propertyParser;
 107     else if(element == "type")pp=&typetypeParser::typeParser;
 108     else if(element == "sequence")pp=&seqtypeParser::seqParser;
 109     else if(element == "objref")pp=&objtypeParser::objParser;
 110     else if(element == "struct")pp=&structtypeParser::structParser;
 111     else if(element == "container")pp=&containertypeParser::containerParser;
 112
 113     else if(element == "inline")pp=&inlinetypeParser<>::inlineParser;
 114     else if(element == "sinline")pp=&sinlinetypeParser<>::sinlineParser;
 115     else if(element == "service")pp=&servicetypeParser<>::serviceParser;
 116     else if(element == "node")pp=&nodetypeParser<>::nodeParser;
 117     else if(element == "datanode")pp=&presettypeParser<>::presetParser;
 118     else if(element == "outnode")pp=&outnodetypeParser<>::outnodeParser;
 119
 120     else if(element == "bloc")pp=&bloctypeParser<>::blocParser;
 121     else if(element == "forloop")pp=&forlooptypeParser<>::forloopParser;
 122     else if(element == "foreach")pp=&foreachlooptypeParser<>::foreachloopParser;
 123     else if(element == "while")pp=&whilelooptypeParser<>::whileloopParser;
 124     else if(element == "switch")pp=&switchtypeParser::switchParser;
 125
 126     else if(element == "control")pp=&controltypeParser<>::controlParser;
 127     else if(element == "datalink")pp=&linktypeParser<>::linkParser;
 128     else if(element == "stream")pp=&streamtypeParser<>::streamParser;
 129     else if(element == "parameter")pp=&parametertypeParser::parameterParser;
 130     else
 131       {
 132         // OCC: san -- Allow external parsers for handling of unknown elements
 133         // and attributes. This capability is used by YACS GUI to read
 134         // graph presentation data
 135         if ( this->_defaultParsersMap )
 136           {
 137             if((this->_defaultParsersMap)->count(element) != 0)
 138               {
 139                 pp=(*(this->_defaultParsersMap))[element];
 140               }
 141             else
 142               {
 143                 std::cerr << "There is no parser for this element type. It will be ignored!" << std::endl;
 144               }
 145           }
 146       }
 147     this->SetUserDataAndPush(pp);
 148     pp->init();
 149     pp->pre();
 150     pp->buildAttr(attr);
 151   }
 152
 153 template <class T>
 154 void proctypeParser<T>::onEnd(const char *el,parser* child)
 155     {
 156       DEBTRACE( "proctypeParser::onEnd: " << el )
 157       std::string element(el);
 158       if(element == "property")this->property(((propertytypeParser*)child)->post());
 159       else if(element == "type")type(((typetypeParser*)child)->post());
 160       else if(element == "sequence")sequence(((seqtypeParser*)child)->post());
 161       else if(element == "objref")objref(((objtypeParser*)child)->post());
 162       else if(element == "struct")struct_(((structtypeParser*)child)->post());
 163       else if(element == "container")container(((containertypeParser*)child)->post());
 164
 165       else if(element == "inline")this->inline_(((inlinetypeParser<>*)child)->post());
 166       else if(element == "sinline")this->sinline(((sinlinetypeParser<>*)child)->post());
 167       else if(element == "service")this->service(((servicetypeParser<>*)child)->post());
 168       else if(element == "node")this->node(((nodetypeParser<>*)child)->post());
 169       else if(element == "datanode")this->preset(((presettypeParser<>*)child)->post());
 170       else if(element == "outnode")this->outnode(((outnodetypeParser<>*)child)->post());
 171
 172       else if(element == "bloc")this->bloc(((bloctypeParser<>*)child)->post());
 173       else if(element == "forloop")this->forloop(((forlooptypeParser<>*)child)->post());
 174       else if(element == "foreach")this->foreach(((foreachlooptypeParser<>*)child)->post());
 175       else if(element == "while")this->while_(((whilelooptypeParser<>*)child)->post());
 176       else if(element == "switch")this->switch_(((switchtypeParser*)child)->post());
 177
 178       else if(element == "control") this->control(((controltypeParser<>*)child)->post());
 179       else if(element == "datalink") this->datalink(((linktypeParser<>*)child)->post());
 180       else if(element == "stream") this->stream(((streamtypeParser<>*)child)->post());
 181       else if(element == "parameter") this->parameter(((parametertypeParser*)child)->post());
 182     }
 183
 184 }
 185
 186 #endif