src/yacsloader/xmlrpcParsers.cxx

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