src/yacsloader/xmlrpcParsers.cxx

   1 // Copyright (C) 2006-2012  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "xmlrpcParsers.hxx"
  21 #include "dataParsers.hxx"
  22 #include <sstream>
  23
  24 namespace YACS
  25 {
  26   arraytypeParser arraytypeParser::arrayParser;
  27   valuetypeParser valuetypeParser::valueParser;
  28   parametertypeParser parametertypeParser::parameterParser;
  29   datatypeParser datatypeParser::dataParser;
  30   memberdatatypeParser memberdatatypeParser::memberdataParser;
  31   structdatatypeParser structdatatypeParser::structdataParser;
  32
  33 static std::string t4[]={"string","objref","double","int","boolean","array","struct",""};
  34
  35   void valuetypeParser::pre (){ }
  36   void valuetypeParser::int_ (const int& d)
  37     {
  38       std::ostringstream os;
  39       os << "<int>"   << d<< "</int>";
  40       _data=os.str();
  41       _v.push_back(_data);
  42     }
  43   void valuetypeParser::boolean (const bool& d)
  44     {
  45       std::ostringstream os;
  46       os << "<boolean>"   << d<< "</boolean>";
  47       _data=os.str();
  48       _v.push_back(_data);
  49     }
  50   void valuetypeParser::double_ (const double& d)
  51     {
  52       std::ostringstream os;
  53       os << "<double>"<< d<< "</double>";
  54       _data=os.str();
  55       _v.push_back(_data);
  56     }
  57   void valuetypeParser::string(const std::string& d)
  58     {
  59       _data="<string>"+ d+ "</string>";
  60       _v.push_back(_data);
  61     }
  62   void valuetypeParser::objref(const std::string& d)
  63     {
  64       _data="<objref>"+ d+ "</objref>";
  65       _v.push_back(_data);
  66     }
  67   void valuetypeParser::array (const std::string& d)
  68     {
  69       _v.push_back(d);
  70     }
  71   void valuetypeParser::struct_ (const std::string& d)
  72     {
  73       _v.push_back(d);
  74     }
  75   std::string valuetypeParser::post()
  76     {
  77       minchoice(t4,1);
  78       std::string value="<value>"+_v.back()+"</value>\n";
  79       _v.pop_back();
  80       return value;
  81     }
  82
  83   void datatypeParser::onStart(const XML_Char* el, const XML_Char** attr)
  84     {
  85       std::string element(el);
  86       parser* pp=&parser::main_parser;
  87       if(element == "value")pp=&valuetypeParser::valueParser;
  88       SetUserDataAndPush(pp);
  89       pp->init();
  90       pp->pre();
  91       pp->buildAttr(attr);
  92     }
  93   void datatypeParser::onEnd(const char *el,parser* child)
  94     {
  95       std::string element(el);
  96       if(element == "value")value(((valuetypeParser*)child)->post());
  97     }
  98   void datatypeParser::pre ()
  99     {
 100       _datas.push_back(_data);
 101       _data="";
 102     }
 103   void datatypeParser::value (const std::string& v){
 104       _data=_data+v;
 105     }
 106   std::string datatypeParser::post()
 107     {
 108       std::string d="<data>\n"+_data+"</data>";
 109       _data=_datas.back();
 110       _datas.pop_back();
 111       return d;
 112     }
 113
 114   void memberdatatypeParser::onStart(const XML_Char* el, const XML_Char** attr)
 115     {
 116       std::string element(el);
 117       parser* pp=&parser::main_parser;
 118       if(element == "name")pp=&stringtypeParser::stringParser;
 119       else if(element == "value")pp=&valuetypeParser::valueParser;
 120       SetUserDataAndPush(pp);
 121       pp->init();
 122       pp->pre();
 123       pp->buildAttr(attr);
 124     }
 125   void memberdatatypeParser::onEnd(const char *el,parser* child)
 126     {
 127       std::string element(el);
 128       this->maxcount("name",1,element);
 129       this->maxcount("value",1,element);
 130       if(element == "name")name(((stringtypeParser*)child)->post());
 131       else if(element == "value")value(((valuetypeParser*)child)->post());
 132     }
 133   void memberdatatypeParser::pre ()
 134     {
 135       _datas.push_back(_data);
 136       _data="";
 137     }
 138   void memberdatatypeParser::name (const std::string& v)
 139     {
 140       _data=_data+"<name>"+v+"</name>";
 141     }
 142   void memberdatatypeParser::value (const std::string& v)
 143     {
 144       _data=_data+v;
 145     }
 146   std::string memberdatatypeParser::post()
 147     {
 148       mincount("value",1);
 149       mincount("name",1);
 150       std::string d="<member>\n"+_data+"</member>";
 151       _data=_datas.back();
 152       _datas.pop_back();
 153       return d;
 154     }
 155
 156   void structdatatypeParser::onStart(const XML_Char* el, const XML_Char** attr)
 157     {
 158       std::string element(el);
 159       parser* pp=&parser::main_parser;
 160       if(element == "member")pp=&memberdatatypeParser::memberdataParser;
 161       SetUserDataAndPush(pp);
 162       pp->init();
 163       pp->pre();
 164       pp->buildAttr(attr);
 165     }
 166   void structdatatypeParser::onEnd(const char *el,parser* child)
 167     {
 168       std::string element(el);
 169       if(element == "member")member(((memberdatatypeParser*)child)->post());
 170     }
 171   void structdatatypeParser::pre ()
 172     {
 173       _membersStack.push_back(_members);
 174       _members="";
 175     }
 176   void structdatatypeParser::member (const std::string& d)
 177     {
 178       _members=_members+d;
 179     }
 180   std::string structdatatypeParser::post()
 181     {
 182       std::string value="<struct>"+_members+"</struct>";
 183       _members=_membersStack.back();
 184       _membersStack.pop_back();
 185       return value;
 186     }
 187
 188   void arraytypeParser::onStart(const XML_Char* el, const XML_Char** attr)
 189     {
 190       std::string element(el);
 191       this->maxcount("data",1,element);
 192       parser* pp=&parser::main_parser;
 193       if(element == "data")pp=&datatypeParser::dataParser;
 194       SetUserDataAndPush(pp);
 195       pp->init();
 196       pp->pre();
 197       pp->buildAttr(attr);
 198     }
 199   void arraytypeParser::onEnd(const char *el,parser* child)
 200     {
 201       std::string element(el);
 202       if(element == "data")data(((datatypeParser*)child)->post());
 203     }
 204   void arraytypeParser::pre (){ }
 205   void arraytypeParser::data (const std::string& d)
 206     {
 207       _arrays.push_back(d);
 208     }
 209   std::string arraytypeParser::post()
 210     {
 211       mincount("data",1);
 212       std::string value="<array>"+_arrays.back()+"</array>";
 213       _arrays.pop_back();
 214       return value;
 215     }
 216
 217
 218 void valuetypeParser::onStart(const XML_Char* el, const XML_Char** attr)
 219 {
 220   std::string element(el);
 221   parser* pp=&parser::main_parser;
 222   this->maxcount("string",1,element);
 223   this->maxcount("objref",1,element);
 224   this->maxcount("double",1,element);
 225   this->maxcount("int",1,element);
 226   this->maxcount("boolean",1,element);
 227   this->maxcount("array",1,element);
 228   this->maxcount("struct",1,element);
 229   this->maxchoice(t4,1,element);
 230   if(element == "string")pp=&stringtypeParser::stringParser;
 231   else if(element == "objref")pp=&stringtypeParser::stringParser;
 232   else if(element == "double")pp=&doubletypeParser::doubleParser;
 233   else if(element == "int")pp=&inttypeParser::intParser;
 234   else if(element == "boolean")pp=&booltypeParser::boolParser;
 235   else if(element == "array")pp=&arraytypeParser::arrayParser;
 236   else if(element == "struct")pp=&structdatatypeParser::structdataParser;
 237   SetUserDataAndPush(pp);
 238   pp->init();
 239   pp->pre();
 240   pp->buildAttr(attr);
 241 }
 242
 243 void valuetypeParser::onEnd(const char *el,parser* child)
 244 {
 245   std::string element(el);
 246   if(element == "string")string(((stringtypeParser*)child)->post());
 247   else if(element == "objref")objref(((stringtypeParser*)child)->post());
 248   else if(element == "double")double_(((doubletypeParser*)child)->post());
 249   else if(element == "int")int_(((inttypeParser*)child)->post());
 250   else if(element == "boolean")boolean(((booltypeParser*)child)->post());
 251   else if(element == "array")array(((arraytypeParser*)child)->post());
 252   else if(element == "struct")struct_(((structdatatypeParser*)child)->post());
 253 }
 254
 255   void parametertypeParser::onStart(const XML_Char* el, const XML_Char** attr)
 256     {
 257       std::string element(el);
 258       this->maxcount("tonode",1,element);
 259       this->maxcount("toport",1,element);
 260       this->maxcount("value",1,element);
 261       parser* pp=&parser::main_parser;
 262       if(element == "tonode")pp=&stringtypeParser::stringParser;
 263       else if(element == "toport")pp=&stringtypeParser::stringParser;
 264       else if(element == "value")pp=&valuetypeParser::valueParser;
 265       SetUserDataAndPush(pp);
 266       pp->init();
 267       pp->pre();
 268       pp->buildAttr(attr);
 269     }
 270   void parametertypeParser::onEnd(const char *el,parser* child)
 271     {
 272       std::string element(el);
 273       if(element == "tonode")tonode(((stringtypeParser*)child)->post());
 274       else if(element == "toport")toport(((stringtypeParser*)child)->post());
 275       else if(element == "value")value(((valuetypeParser*)child)->post());
 276     }
 277     void parametertypeParser::pre (){}
 278     void parametertypeParser::tonode (const std::string& name){
 279       _param._tonode=name;
 280     }
 281     void parametertypeParser::toport (const std::string& name){
 282       _param._toport=name;
 283     }
 284     void parametertypeParser::value (const std::string& name){
 285       _param._value=name;
 286     }
 287     myparam& parametertypeParser::post(){
 288       mincount("tonode",1);
 289       mincount("toport",1);
 290       mincount("value",1);
 291       return _param;
 292     }
 293
 294 }