src/yacsloader/xmlrpcParsers.cxx

   1
   2 #include "xmlrpcParsers.hxx"
   3 #include "dataParsers.hxx"
   4 #include <sstream>
   5
   6 namespace YACS
   7 {
   8   arraytypeParser arraytypeParser::arrayParser;
   9   valuetypeParser valuetypeParser::valueParser;
  10   parametertypeParser parametertypeParser::parameterParser;
  11   datatypeParser datatypeParser::dataParser;
  12   memberdatatypeParser memberdatatypeParser::memberdataParser;
  13   structdatatypeParser structdatatypeParser::structdataParser;
  14
  15 static std::string t4[]={"string","objref","double","int","boolean","array","struct",""};
  16
  17   void valuetypeParser::pre (){ }
  18   void valuetypeParser::int_ (const int& d)
  19     {
  20       std::ostringstream os;
  21       os << "<int>"   << d<< "</int>";
  22       _data=os.str();
  23       _v.push_back(_data);
  24     }
  25   void valuetypeParser::boolean (const bool& d)
  26     {
  27       std::ostringstream os;
  28       os << "<boolean>"   << d<< "</boolean>";
  29       _data=os.str();
  30       _v.push_back(_data);
  31     }
  32   void valuetypeParser::double_ (const double& d)
  33     {
  34       std::ostringstream os;
  35       os << "<double>"<< d<< "</double>";
  36       _data=os.str();
  37       _v.push_back(_data);
  38     }
  39   void valuetypeParser::string(const std::string& d)
  40     {
  41       _data="<string>"+ d+ "</string>";
  42       _v.push_back(_data);
  43     }
  44   void valuetypeParser::objref(const std::string& d)
  45     {
  46       _data="<objref>"+ d+ "</objref>";
  47       _v.push_back(_data);
  48     }
  49   void valuetypeParser::array (const std::string& d)
  50     {
  51       _v.push_back(d);
  52     }
  53   void valuetypeParser::struct_ (const std::string& d)
  54     {
  55       _v.push_back(d);
  56     }
  57   std::string valuetypeParser::post()
  58     {
  59       minchoice(t4,1);
  60       std::string value="<value>"+_v.back()+"</value>\n";
  61       _v.pop_back();
  62       return value;
  63     }
  64
  65   void datatypeParser::onStart(const XML_Char* el, const XML_Char** attr)
  66     {
  67       std::string element(el);
  68       parser* pp=&parser::main_parser;
  69       if(element == "value")pp=&valuetypeParser::valueParser;
  70       SetUserDataAndPush(pp);
  71       pp->init();
  72       pp->pre();
  73       pp->buildAttr(attr);
  74     }
  75   void datatypeParser::onEnd(const char *el,parser* child)
  76     {
  77       std::string element(el);
  78       if(element == "value")value(((valuetypeParser*)child)->post());
  79     }
  80   void datatypeParser::pre ()
  81     {
  82       _datas.push_back(_data);
  83       _data="";
  84     }
  85   void datatypeParser::value (const std::string& v){
  86       _data=_data+v;
  87     }
  88   std::string datatypeParser::post()
  89     {
  90       mincount("value",1);
  91       std::string d="<data>\n"+_data+"</data>";
  92       _data=_datas.back();
  93       _datas.pop_back();
  94       return d;
  95     }
  96
  97   void memberdatatypeParser::onStart(const XML_Char* el, const XML_Char** attr)
  98     {
  99       std::string element(el);
 100       parser* pp=&parser::main_parser;
 101       if(element == "name")pp=&stringtypeParser::stringParser;
 102       else if(element == "value")pp=&valuetypeParser::valueParser;
 103       SetUserDataAndPush(pp);
 104       pp->init();
 105       pp->pre();
 106       pp->buildAttr(attr);
 107     }
 108   void memberdatatypeParser::onEnd(const char *el,parser* child)
 109     {
 110       std::string element(el);
 111       this->maxcount("name",1,element);
 112       this->maxcount("value",1,element);
 113       if(element == "name")name(((stringtypeParser*)child)->post());
 114       else if(element == "value")value(((valuetypeParser*)child)->post());
 115     }
 116   void memberdatatypeParser::pre ()
 117     {
 118       _datas.push_back(_data);
 119       _data="";
 120     }
 121   void memberdatatypeParser::name (const std::string& v)
 122     {
 123       _data=_data+"<name>"+v+"</name>";
 124     }
 125   void memberdatatypeParser::value (const std::string& v)
 126     {
 127       _data=_data+v;
 128     }
 129   std::string memberdatatypeParser::post()
 130     {
 131       mincount("value",1);
 132       mincount("name",1);
 133       std::string d="<member>\n"+_data+"</member>";
 134       _data=_datas.back();
 135       _datas.pop_back();
 136       return d;
 137     }
 138
 139   void structdatatypeParser::onStart(const XML_Char* el, const XML_Char** attr)
 140     {
 141       std::string element(el);
 142       parser* pp=&parser::main_parser;
 143       if(element == "member")pp=&memberdatatypeParser::memberdataParser;
 144       SetUserDataAndPush(pp);
 145       pp->init();
 146       pp->pre();
 147       pp->buildAttr(attr);
 148     }
 149   void structdatatypeParser::onEnd(const char *el,parser* child)
 150     {
 151       std::string element(el);
 152       if(element == "member")member(((memberdatatypeParser*)child)->post());
 153     }
 154   void structdatatypeParser::pre ()
 155     {
 156       _membersStack.push_back(_members);
 157       _members="";
 158     }
 159   void structdatatypeParser::member (const std::string& d)
 160     {
 161       _members=_members+d;
 162     }
 163   std::string structdatatypeParser::post()
 164     {
 165       mincount("member",1);
 166       std::string value="<struct>"+_members+"</struct>";
 167       _members=_membersStack.back();
 168       _membersStack.pop_back();
 169       return value;
 170     }
 171
 172   void arraytypeParser::onStart(const XML_Char* el, const XML_Char** attr)
 173     {
 174       std::string element(el);
 175       this->maxcount("data",1,element);
 176       parser* pp=&parser::main_parser;
 177       if(element == "data")pp=&datatypeParser::dataParser;
 178       SetUserDataAndPush(pp);
 179       pp->init();
 180       pp->pre();
 181       pp->buildAttr(attr);
 182     }
 183   void arraytypeParser::onEnd(const char *el,parser* child)
 184     {
 185       std::string element(el);
 186       if(element == "data")data(((datatypeParser*)child)->post());
 187     }
 188   void arraytypeParser::pre (){ }
 189   void arraytypeParser::data (const std::string& d)
 190     {
 191       _arrays.push_back(d);
 192     }
 193   std::string arraytypeParser::post()
 194     {
 195       mincount("data",1);
 196       std::string value="<array>"+_arrays.back()+"</array>";
 197       _arrays.pop_back();
 198       return value;
 199     }
 200
 201
 202 void valuetypeParser::onStart(const XML_Char* el, const XML_Char** attr)
 203 {
 204   std::string element(el);
 205   parser* pp=&parser::main_parser;
 206   this->maxcount("string",1,element);
 207   this->maxcount("objref",1,element);
 208   this->maxcount("double",1,element);
 209   this->maxcount("int",1,element);
 210   this->maxcount("boolean",1,element);
 211   this->maxcount("array",1,element);
 212   this->maxcount("struct",1,element);
 213   this->maxchoice(t4,1,element);
 214   if(element == "string")pp=&stringtypeParser::stringParser;
 215   else if(element == "objref")pp=&stringtypeParser::stringParser;
 216   else if(element == "double")pp=&doubletypeParser::doubleParser;
 217   else if(element == "int")pp=&inttypeParser::intParser;
 218   else if(element == "boolean")pp=&booltypeParser::boolParser;
 219   else if(element == "array")pp=&arraytypeParser::arrayParser;
 220   else if(element == "struct")pp=&structdatatypeParser::structdataParser;
 221   SetUserDataAndPush(pp);
 222   pp->init();
 223   pp->pre();
 224   pp->buildAttr(attr);
 225 }
 226
 227 void valuetypeParser::onEnd(const char *el,parser* child)
 228 {
 229   std::string element(el);
 230   if(element == "string")string(((stringtypeParser*)child)->post());
 231   else if(element == "objref")objref(((stringtypeParser*)child)->post());
 232   else if(element == "double")double_(((doubletypeParser*)child)->post());
 233   else if(element == "int")int_(((inttypeParser*)child)->post());
 234   else if(element == "boolean")boolean(((booltypeParser*)child)->post());
 235   else if(element == "array")array(((arraytypeParser*)child)->post());
 236   else if(element == "struct")struct_(((structdatatypeParser*)child)->post());
 237 }
 238
 239   void parametertypeParser::onStart(const XML_Char* el, const XML_Char** attr)
 240     {
 241       std::string element(el);
 242       this->maxcount("tonode",1,element);
 243       this->maxcount("toport",1,element);
 244       this->maxcount("value",1,element);
 245       parser* pp=&parser::main_parser;
 246       if(element == "tonode")pp=&stringtypeParser::stringParser;
 247       else if(element == "toport")pp=&stringtypeParser::stringParser;
 248       else if(element == "value")pp=&valuetypeParser::valueParser;
 249       SetUserDataAndPush(pp);
 250       pp->init();
 251       pp->pre();
 252       pp->buildAttr(attr);
 253     }
 254   void parametertypeParser::onEnd(const char *el,parser* child)
 255     {
 256       std::string element(el);
 257       if(element == "tonode")tonode(((stringtypeParser*)child)->post());
 258       else if(element == "toport")toport(((stringtypeParser*)child)->post());
 259       else if(element == "value")value(((valuetypeParser*)child)->post());
 260     }
 261     void parametertypeParser::pre (){}
 262     void parametertypeParser::tonode (const std::string& name){
 263       _param._tonode=name;
 264     }
 265     void parametertypeParser::toport (const std::string& name){
 266       _param._toport=name;
 267     }
 268     void parametertypeParser::value (const std::string& name){
 269       _param._value=name;
 270     }
 271     myparam& parametertypeParser::post(){
 272       mincount("tonode",1);
 273       mincount("toport",1);
 274       mincount("value",1);
 275       return _param;
 276     }
 277
 278 }