- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

# fmp.hxx

    00001 // fmp.hxx: this file is part of the Vaucanson project.
    00002 //
    00003 // Vaucanson, a generic library for finite state machines.
    00004 //
    00005 // Copyright (C) 2007, 2008, 2010 The Vaucanson Group.
    00006 //
    00007 // This program is free software; you can redistribute it and/or
    00008 // modify it under the terms of the GNU General Public License
    00009 // as published by the Free Software Foundation; either version 2
    00010 // of the License, or (at your option) any later version.
    00011 //
    00012 // The complete GNU General Public Licence Notice can be found as the
    00013 // `COPYING' file in the root directory.
    00014 //
    00015 // The Vaucanson Group consists of people listed in the `AUTHORS' file.
    00016 //
    00017
    00018 #ifndef VCSN_XML_CONTEXTS_FMP_HXX
    00019 # define VCSN_XML_CONTEXTS_FMP_HXX
    00020
    00021 # include <vaucanson/xml/builders.hh>
    00022
    00023 namespace vcsn
    00024 {
    00025   namespace xml
    00026   {
    00030     template <typename T>
    00031     FreeMonoidProductHandler<T>::FreeMonoidProductHandler (xercesc::SAX2XMLReader* parser,
    00032                                  Handler& root,
    00033                                  T& monoid)
    00034       : Handler(parser, root),
    00035         monoid_(monoid),
    00036         unsuph_(parser, *this),
    00037         first_(true)
    00038     {
    00039     }
    00040
    00041     template <typename T>
    00042     void
    00043     FreeMonoidProductHandler<T>::start (const XMLCh* const,
    00044                                  const XMLCh* const localname,
    00045                                  const XMLCh* const,
    00046                                  const xercesc::Attributes& attrs)
    00047     {
    00048       if (xercesc::XMLString::equals(eq_.monoid, localname))
    00049       {
    00050         if (first_)
    00051         {
    00052           monoidh_ = builders::create_monoidh(monoid_.first_monoid(), attrs, parser_, *this);
    00053           first_ = false;
    00054         }
    00055         else
    00056         {
    00057           delete monoidh_;
    00058           monoidh_ = builders::create_monoidh(monoid_.second_monoid(), attrs, parser_, *this);
    00059         }
    00060         parser_->setContentHandler(monoidh_);
    00061       }
    00062       else if (xercesc::XMLString::equals(eq_.writingData, localname))
    00063       {
    00064         algebra::MonoidRep<T> rep;
    00065         if (tools::has_attribute(attrs, eq_.identitySymbol))
    00066           rep.empty = xmlstr(tools::get_attribute(attrs, eq_.identitySymbol));
    00067         if (tools::has_attribute(attrs, eq_.concat))
    00068           rep.concat = xmlstr(tools::get_attribute(attrs, eq_.concat));
    00069         monoid_.set_representation(rep);
    00070         parser_->setContentHandler(&unsuph_);
    00071       }
    00072       else
    00073         error::token(localname);
    00074     }
    00075
    00076     template <typename T>
    00077     void
    00078     FreeMonoidProductHandler<T>::end (const XMLCh* const,
    00079                                const XMLCh* const localname,
    00080                                const XMLCh* const)
    00081     {
    00082       delete monoidh_;
    00083       if (xercesc::XMLString::equals(eq_.monoid, localname))
    00084         parser_->setContentHandler(&root_);
    00085       else
    00086         error::token(localname);
    00087     }
    00088
    00092     template <typename S, typename M1, typename M2>
    00093     SeriesRepresentationHandler<FMPsreptype>::
    00094     SeriesRepresentationHandler(xercesc::SAX2XMLReader* parser,
    00095                                 Handler& root,
    00096                                 FMPsreptype& srep)
    00097       : Handler(parser, root),
    00098         rep_(srep),
    00099         reph_(0),
    00100         unsuph_(parser, *this),
    00101         first_(true)
    00102     {
    00103     }
    00104
    00105     template <typename S, typename M1, typename M2>
    00106     void
    00107     SeriesRepresentationHandler<FMPsreptype>::start(const XMLCh* const,
    00108                                                     const XMLCh* const localname,
    00109                                                     const XMLCh* const,
    00110                                                     const xercesc::Attributes& attrs)
    00111     {
    00112       if (xercesc::XMLString::equals(eq_.writingData, localname))
    00113       {
    00114         if (first_)
    00115         {
    00116           reph_ = builders::create_series_representationh(rep_.first_representation(), attrs, parser_, *this, eq_);
    00117           first_ = false;
    00118         }
    00119         else
    00120         {
    00121           delete reph_;
    00122           reph_ = builders::create_series_representationh(rep_.second_representation(), attrs, parser_, *this, eq_);
    00123         }
    00124         parser_->setContentHandler(reph_);
    00125       }
    00126       else
    00127         error::token(localname);
    00128     }
    00129
    00130     template <typename S, typename M1, typename M2>
    00131     void
    00132     SeriesRepresentationHandler<FMPsreptype>::end(const XMLCh* const,
    00133                                                   const XMLCh* const localname,
    00134                                                   const XMLCh* const)
    00135     {
    00136       using namespace xercesc;
    00137
    00138       delete reph_;
    00139       if (XMLString::equals(eq_.writingData, localname))
    00140         parser_->setContentHandler(&root_);
    00141       else
    00142         error::token(localname);
    00143     }
    00144
    00145     namespace builders
    00146     {
    00147       TParamFMP
    00148       typename FMPtype::monoid_t*
    00149       create_monoid (FMPtype& param,
    00150                      const XMLCh* const localname,
    00151                      const xercesc::Attributes& attrs,
    00152                      XMLEq& eq)
    00153       {
    00154         typename FMPtype::monoid_t::first_monoid_t::alphabet_t  at1;
    00155         typename FMPtype::monoid_t::second_monoid_t::alphabet_t at2;
    00156         typename FMPtype::monoid_t::first_monoid_t      md1(at1);
    00157         typename FMPtype::monoid_t::second_monoid_t     md2(at2);
    00158         typedef typename FMPtype::monoid_t              monoid_t;
    00159
    00160         monoid_t* monoid = new monoid_t(md1, md2);
    00161         builders::check_monoid_consistency(param, localname, attrs, eq);
    00162         return monoid;
    00163       }
    00164
    00165       template <typename M1, typename M2>
    00166       Handler*
    00167       create_monoidh (vcsn::algebra::FreeMonoidProduct<M1, M2>& monoid,
    00168                       const xercesc::Attributes&,
    00169                       xercesc::SAX2XMLReader* parser,
    00170                       Handler& root)
    00171       {
    00172         typedef typename vcsn::algebra::FreeMonoidProduct<M1, M2> monoid_t;
    00173         return new FreeMonoidProductHandler<monoid_t>(parser, root, monoid);
    00174       }
    00175     } // !builders
    00176
    00177     /*
    00178      * ProdMonElmtHandler
    00179      */
    00180     template <typename T>
    00181     ProdMonElmtHandler<T>::ProdMonElmtHandler (xercesc::SAX2XMLReader* parser,
    00182                                Handler& root,
    00183                                T param)
    00184       : RegexpHandler<T>(parser, root, param),
    00185         in_(1),
    00186         count_(1),
    00187         m1_(param.structure().monoid().first_monoid()),
    00188         m2_(param.structure().monoid().second_monoid())
    00189     {
    00190       end_ = eq_.monElmt;
    00191     }
    00192
    00193     template <typename T>
    00194     void
    00195     ProdMonElmtHandler<T>::start(const XMLCh* const,
    00196                                  const XMLCh* const localname,
    00197                                  const XMLCh* const,
    00198                                  const xercesc::Attributes& attrs)
    00199     {
    00200       using namespace xercesc;
    00201
    00202       typedef typename T::set_t::monoid_t               monoid_t;
    00203       typedef typename monoid_t::first_monoid_t         first_monoid_t;
    00204       typedef typename monoid_t::second_monoid_t        second_monoid_t;
    00205       typedef typename first_monoid_t::alphabet_t       first_alphabet_t;
    00206       typedef typename second_monoid_t::alphabet_t      second_alphabet_t;
    00207       typedef typename first_alphabet_t::letter_t       first_letter_t;
    00208       typedef typename second_alphabet_t::letter_t      second_letter_t;
    00209
    00210       if (XMLString::equals(eq_.monElmt, localname))
    00211       {
    00212         in_++;
    00213         count_++;
    00214         if (in_ > 2)
    00215           error::token(localname);
    00216       }
    00217       else if (XMLString::equals(eq_.one, localname) && (in_ == 1))
    00218       {
    00219         in_++;
    00220         count_++;
    00221         if (count_ == 2)
    00222           m1_ = algebra::identity_as<typename T::monoid_elt_t::first_monoid_elt_value_t>
    00223             ::of(param_.structure().monoid().first_monoid());
    00224         else if (count_ == 3)
    00225           m2_ = algebra::identity_as<typename T::monoid_elt_t::second_monoid_elt_value_t>
    00226             ::of(param_.structure().monoid().second_monoid());
    00227         else
    00228           error::token(localname);
    00229       }
    00230       else if (XMLString::equals(eq_.monGen, localname))
    00231       {
    00232         const std::string val(xmlstr(tools::get_attribute(attrs, "value")));
    00233         if (in_ == 2 && count_ == 2)
    00234         {
    00235           std::pair<bool, first_letter_t> tmp =
    00236                 parse_letter(m1_.structure().alphabet(), val);
    00237           if (tmp.first)
    00238             m1_ *= tmp.second;
    00239           else
    00240             error::attrs(localname, "value", val);
    00241         }
    00242         else if (in_ == 2 && count_ == 3)
    00243         {
    00244           std::pair<bool, second_letter_t> tmp =
    00245                 parse_letter(m2_.structure().alphabet(), val);
    00246           if (tmp.first)
    00247             m2_ *= tmp.second;
    00248           else
    00249             error::attrs(localname, "value", val);
    00250         }
    00251         else
    00252           error::token(localname);
    00253       }
    00254       else
    00255         error::token(localname);
    00256     }
    00257
    00258     template <typename T>
    00259     void
    00260     ProdMonElmtHandler<T>::end (const XMLCh* const,
    00261                                const XMLCh* const localname,
    00262                                const XMLCh* const)
    00263     {
    00264       using namespace xercesc;
    00265       if (XMLString::equals(end_, localname))
    00266       {
    00267         if (in_ == 1 && count_ == 3)
    00268         {
    00269           // FIXME awful... but didn't find an easier way.
    00270           typename T::monoid_elt_value_t m(m1_.value(), m2_.value());
    00271           typename T::semiring_elt_value_t w =
    00272             algebra::identity_as<typename T::semiring_elt_value_t>::of(param_.structure().semiring()).value();
    00273           param_.assoc(m, w);
    00274           parser_->setContentHandler(&root_);
    00275         }
    00276         in_--;
    00277       }
    00278       else if (XMLString::equals(eq_.one, localname))
    00279         in_--;
    00280       else if (!XMLString::equals(eq_.monGen, localname))
    00281         error::token(localname);
    00282     }
    00283
    00284
    00285     namespace builders
    00286     {
    00287       SParamFMP
    00288       RegexpHandler<FMPseries >*
    00289       create_monElmth(xercesc::SAX2XMLReader* parser,
    00290                       RegexpHandler<FMPseries >& root,
    00291                       FMPseries param)
    00292       {
    00293         return new ProdMonElmtHandler<FMPseries >(parser, root,
    00294             algebra::zero_as<typename FMPseries::value_t>::of(param.structure()));
    00295       }
    00296     } // !builders
    00297
    00301     namespace builders
    00302     {
    00303       TParamFMP
    00304       void
    00305       check_monoid_consistency (FMPtype&,
    00306                                 const XMLCh* const localname,
    00307                                 const xercesc::Attributes& attrs,
    00308                                 XMLEq&)
    00309       {
    00310         std::string val(xmlstr(tools::get_attribute(attrs, "type")));
    00311         if (val != "product")
    00312           error::attrs(localname, "type", val);
    00313         val = xmlstr(tools::get_attribute(attrs, "prodDim"));
    00314         if (val != "2")
    00315           error::attrs(localname, "prodDim", val);
    00316       };
    00317     } // !builders
    00318
    00322     namespace builders
    00323     {
    00324
    00325
    00326       template <typename S>
    00327       void
    00328       do_create_type_writingData_node(const S& s,
    00329                                       xercesc::DOMDocument* doc,
    00330                                       xercesc::DOMElement* root)
    00331       {
    00332         xercesc::DOMElement* writingData = tools::create_element(doc, "writingData");
    00333         tools::set_attribute(writingData, "plusSym", s.representation()->plus);
    00334         tools::set_attribute(writingData, "timesSym", s.representation()->times);
    00335         tools::set_attribute(writingData, "starSym", s.representation()->star);
    00336         tools::set_attribute(writingData, "zeroSym", s.representation()->zero);
    00337         tools::set_attribute(writingData, "weightOpening", s.representation()->open_weight);
    00338         tools::set_attribute(writingData, "weightClosing", s.representation()->close_weight);
    00339         tools::set_attribute(writingData, "openPar", s.representation()->open_par);
    00340         tools::set_attribute(writingData, "closePar", s.representation()->close_par);
    00341         tools::set_attribute(writingData, "spacesSym", s.representation()->spaces.front());
    00342
    00343         xercesc::DOMElement* firstWritingData = tools::create_element(doc, "writingData");
    00344         tools::set_attribute(firstWritingData, "plusSym",
    00345                              s.representation()->first_representation().plus);
    00346         tools::set_attribute(firstWritingData, "timesSym",
    00347                              s.representation()->first_representation().times);
    00348         tools::set_attribute(firstWritingData, "starSym",
    00349                              s.representation()->first_representation().star);
    00350         tools::set_attribute(firstWritingData, "zeroSym",
    00351                              s.representation()->first_representation().zero);
    00352         tools::set_attribute(firstWritingData, "weightOpening",
    00353                              s.representation()->first_representation().open_weight);
    00354         tools::set_attribute(firstWritingData, "weightClosing",
    00355                              s.representation()->first_representation().close_weight);
    00356         tools::set_attribute(firstWritingData, "openPar",
    00357                              s.representation()->first_representation().open_par);
    00358         tools::set_attribute(firstWritingData, "closePar",
    00359                              s.representation()->first_representation().close_par);
    00360         tools::set_attribute(firstWritingData, "spacesSym",
    00361                              s.representation()->first_representation().spaces.front());
    00362         writingData->appendChild(firstWritingData);
    00363
    00364         xercesc::DOMElement* secondWritingData = tools::create_element(doc, "writingData");
    00365         tools::set_attribute(secondWritingData, "plusSym",
    00366                              s.representation()->second_representation().plus);
    00367         tools::set_attribute(secondWritingData, "timesSym",
    00368                              s.representation()->second_representation().times);
    00369         tools::set_attribute(secondWritingData, "starSym",
    00370                              s.representation()->second_representation().star);
    00371         tools::set_attribute(secondWritingData, "zeroSym",
    00372                              s.representation()->second_representation().zero);
    00373         tools::set_attribute(secondWritingData, "weightOpening",
    00374                              s.representation()->second_representation().open_weight);
    00375         tools::set_attribute(secondWritingData, "weightClosing",
    00376                              s.representation()->second_representation().close_weight);
    00377         tools::set_attribute(secondWritingData, "openPar",
    00378                              s.representation()->second_representation().open_par);
    00379         tools::set_attribute(secondWritingData, "closePar",
    00380                              s.representation()->second_representation().close_par);
    00381         tools::set_attribute(secondWritingData, "spacesSym",
    00382                              s.representation()->second_representation().spaces.front());
    00383         writingData->appendChild(secondWritingData);
    00384
    00385         root->appendChild(writingData);
    00386       }
    00387
    00388       TParamFMP
    00389       void
    00390       create_type_writingData_node(const FMPtype& aut,
    00391                                    xercesc::DOMDocument* doc,
    00392                                    xercesc::DOMElement* root)
    00393       {
    00394         do_create_type_writingData_node(aut.series(), doc, root);
    00395       }
    00396
    00397       TParamFMP
    00398       void
    00399       create_type_writingData_node(const FMPseries& s,
    00400                                    xercesc::DOMDocument* doc,
    00401                                    xercesc::DOMElement* root)
    00402       {
    00403         do_create_type_writingData_node(s.series(), doc, root);
    00404       }
    00405
    00406       TParamFMP
    00407       void
    00408       do_create_monoid_node(const vcsn::algebra::Series<S, vcsn::algebra::FreeMonoidProduct<M1, M2> >& s,
    00409                             xercesc::DOMDocument* doc,
    00410                             xercesc::DOMElement* root)
    00411       {
    00412         xercesc::DOMElement* node = tools::create_element(doc, "monoid");
    00413         tools::set_attribute(node, "type", "product");
    00414         tools::set_attribute(node, "prodDim", "2");
    00415         root->appendChild(node);
    00416
    00417         xercesc::DOMElement* writingData = tools::create_element(doc, "writingData");
    00418         tools::set_attribute(writingData, "identitySym", s.monoid().representation()->empty);
    00419         tools::set_attribute(writingData, "timesSym", s.monoid().representation()->concat);
    00420         node->appendChild(writingData);
    00421
    00422         xercesc::DOMElement* first = tools::create_element(doc, "monoid");
    00423         tools::set_attribute(first, "type", "free");
    00424         tools::set_attribute(first, "genDescrip", "enum");
    00425         tools::set_attribute(first, "genKind", algebra::letter_traits<typename M1::alphabet_t::letter_t>::kind());
    00426         node->appendChild(first);
    00427
    00428         xercesc::DOMElement* writingData1 = tools::create_element(doc, "writingData");
    00429         tools::set_attribute(writingData1, "identitySym", s.monoid().first_monoid().representation()->empty);
    00430         tools::set_attribute(writingData1, "timesSym", s.monoid().first_monoid().representation()->concat);
    00431         first->appendChild(writingData1);
    00432
    00433         typedef typename M1::alphabet_t::const_iterator first_alphabet_iterator;
    00434         for_all_letters_(first_, l, s.monoid().first_monoid().alphabet())
    00435         {
    00436           std::ostringstream letter;
    00437           xercesc::DOMElement* gen = tools::create_element(doc, "monGen");
    00438           letter << *l;
    00439           tools::set_attribute(gen, "value", letter.str());
    00440           first->appendChild(gen);
    00441         }
    00442         tools::set_attribute(first, "genSort", get_monoid_gen_sort(*(s.monoid().first_monoid().alphabet().begin())));
    00443         xercesc::DOMElement* second = tools::create_element(doc, "monoid");
    00444         tools::set_attribute(second, "type", "free");
    00445         tools::set_attribute(second, "genDescrip", "enum");
    00446         tools::set_attribute(second, "genKind", algebra::letter_traits<typename M2::alphabet_t::letter_t>::kind());
    00447         node->appendChild(second);
    00448
    00449         xercesc::DOMElement* writingData2 = tools::create_element(doc, "writingData");
    00450         tools::set_attribute(writingData2, "identitySym", s.monoid().second_monoid().representation()->empty);
    00451         tools::set_attribute(writingData2, "timesSym", s.monoid().second_monoid().representation()->concat);
    00452         second->appendChild(writingData2);
    00453
    00454         typedef typename M2::alphabet_t::const_iterator second_alphabet_iterator;
    00455         for_all_letters_(second_, l, s.monoid().second_monoid().alphabet())
    00456         {
    00457           std::ostringstream letter;
    00458           xercesc::DOMElement* gen = tools::create_element(doc, "monGen");
    00459           letter << *l;
    00460           tools::set_attribute(gen, "value", letter.str());
    00461           second->appendChild(gen);
    00462         }
    00463         tools::set_attribute(second, "genSort", get_monoid_gen_sort(*(s.monoid().second_monoid().alphabet().begin())));
    00464       }
    00465
    00466       TParamFMP
    00467       void
    00468       create_monoid_node(const FMPtype& aut,
    00469                          xercesc::DOMDocument* doc,
    00470                          xercesc::DOMElement* root)
    00471       {
    00472         do_create_monoid_node<S,T,M1,M2>(aut.series(), doc, root);
    00473       }
    00474
    00475       TParamFMP
    00476       void
    00477       create_monoid_node(const FMPseries& s,
    00478                          xercesc::DOMDocument* doc,
    00479                          xercesc::DOMElement* root)
    00480       {
    00481         do_create_monoid_node<S,T,M1,M2>(s.series(), doc, root);
    00482       }
    00483
    00484
    00485
    00486       /* FIXME there should not be 2 but one function here... however,
    00487       ** when we add a template T instead of int the function is not called
    00488       ** anymore... there is a probleme in the dispatch */
    00489       template <>
    00490       void
    00491       create_monElmt_node(const std::pair<std::string, std::string>& m,
    00492                          xercesc::DOMDocument* doc,
    00493                            xercesc::DOMElement* root)
    00494       {
    00495         xercesc::DOMElement* node;
    00496         if (m.first.empty() && m.second.empty())
    00497           node = tools::create_element(doc, "one");
    00498         else
    00499         {
    00500           node = tools::create_element(doc, "monElmt");
    00501           create_monElmt_node(m.first, doc, node);
    00502           create_monElmt_node(m.second, doc, node);
    00503         }
    00504         root->appendChild(node);
    00505       }
    00506
    00507       template <>
    00508       void
    00509       create_monElmt_node(const std::pair<std::basic_string<int>, std::basic_string<int> >& m,
    00510                          xercesc::DOMDocument* doc,
    00511                            xercesc::DOMElement* root)
    00512       {
    00513         xercesc::DOMElement* node;
    00514         if (m.first.empty() && m.second.empty())
    00515           node = tools::create_element(doc, "one");
    00516         else
    00517         {
    00518           node = tools::create_element(doc, "monElmt");
    00519           create_monElmt_node(m.first, doc, node);
    00520           create_monElmt_node(m.second, doc, node);
    00521         }
    00522         root->appendChild(node);
    00523       }
    00524     } // !builders
    00525   } // !xml
    00526 } // !vcsn
    00527
    00528 #endif // !VCSN_XML_CONTEXTS_FMP_HXX