Vaucanson: handlers.hxx Source File

00001 // handlers.hxx: this file is part of the Vaucanson project.
00002 //
00003 // Vaucanson, a generic library for finite state machines.
00004 //
00005 // Copyright (C) 2005, 2006, 2007 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 HANDLERS_HXX
00019 # define HANDLERS_HXX
00020 
00032 # include <iostream>
00033 # include <xercesc/sax2/Attributes.hpp>
00034 
00035 # include <vaucanson/xml/strings.hh>
00036 # include <vaucanson/xml/builders.hh>
00037 
00038 namespace vcsn
00039 {
00040   namespace xml
00041   {
00042     /*
00043      * ErrHandler
00044      */
00045     void
00046     ErrHandler::warning (const xercesc::SAXParseException& exc)
00047     {
00048       char* msg = xercesc::XMLString::transcode(exc.getMessage());
00049       std::cout << "Warning: " << msg << std::endl;
00050       xercesc::XMLString::release(&msg);
00051     }
00052 
00053     void
00054     ErrHandler::error (const xercesc::SAXParseException& exc)
00055     {
00056       char* msg = xercesc::XMLString::transcode(exc.getMessage());
00057       std::cout << "Error: " << msg << std::endl;
00058       xercesc::XMLString::release(&msg);
00059     }
00060 
00061     void
00062     ErrHandler::fatalError (const xercesc::SAXParseException& exc)
00063     {
00064       char* msg = xercesc::XMLString::transcode(exc.getMessage());
00065       std::cout << "Fatal error: " << msg << std::endl;
00066       xercesc::XMLString::release(&msg);
00067     }
00068 
00069     /*
00070      * Handler
00071      */
00072     Handler::Handler (xercesc::SAX2XMLReader* parser,
00073                       XMLEq& eq,
00074                       xercesc::DefaultHandler& root)
00075       : DefaultHandler(),
00076         parser_(parser),
00077         root_(root),
00078         eq_(eq)
00079     {
00080     }
00081 
00082     /*
00083      * UnsupHandler
00084      */
00085     UnsupHandler::UnsupHandler (xercesc::DefaultHandler& root,
00086                                 xercesc::SAX2XMLReader* parser)
00087       : DefaultHandler(),
00088         parser_(parser),
00089         root_(root),
00090         depth_(1)
00091     {
00092     }
00093 
00094     void
00095     UnsupHandler::startElement (const XMLCh* const,
00096                                 const XMLCh* const,
00097                                 const XMLCh* const,
00098                                 const xercesc::Attributes&)
00099     {
00100       depth_++;
00101     }
00102 
00103     void
00104     UnsupHandler::endElement (const XMLCh* const,
00105                               const XMLCh* const,
00106                               const XMLCh* const)
00107     {
00108       depth_--;
00109       if (depth_ <= 0)
00110       {
00111         parser_->setContentHandler(&root_);
00112         depth_ = 1;
00113       }
00114     }
00115 
00116     /*
00117      * AutHandler
00118      */
00119     template <typename T>
00120     AutHandler<T>::AutHandler (T& aut,
00121                                xercesc::SAX2XMLReader* parser,
00122                                XMLEq& eq)
00123       : DefaultHandler(),
00124         parser_(parser),
00125         eq_(eq),
00126         aut_(aut),
00127         end_(false),
00128         unsuph_(*this, parser),
00129         contenth_(*this, aut, parser, eq),
00130         typeh_(*this, aut, parser, eq)
00131     {
00132     }
00133 
00134     template <typename T>
00135     void
00136     AutHandler<T>::startElement (const XMLCh* const uri,
00137                                  const XMLCh* const localname,
00138                                  const XMLCh* const,
00139                                  const xercesc::Attributes& attrs)
00140     {
00141       using namespace xercesc;
00142       if (XMLString::equals(eq_.automaton, localname) && !end_)
00143       {
00144         const XMLCh* autname = builders::get_attribute(attrs, "name", uri);
00145         if (autname != 0)
00146           aut_.geometry().name() = xml2str(autname);
00147       }
00148       else // <labelType>, <content>
00149       {
00150         if (XMLString::equals(eq_.type, localname))
00151           parser_->setContentHandler(&typeh_);
00152         else
00153           if (XMLString::equals(eq_.content, localname))
00154             parser_->setContentHandler(&contenth_);
00155           else
00156             if (XMLString::equals(eq_.drawing, localname))
00157               parser_->setContentHandler(&unsuph_);
00158             else
00159               if (XMLString::equals(eq_.geometry, localname))
00160                 parser_->setContentHandler(&unsuph_);
00161               // else
00162               // <FSMXML>
00163       }
00164     }
00165 
00166     template <typename T>
00167     void
00168     AutHandler<T>::endElement (const XMLCh* const,
00169                                const XMLCh* const localname,
00170                                const XMLCh* const)
00171     {
00172       using namespace xercesc;
00173       if (XMLString::equals(eq_.automaton, localname))
00174         end_ = true;
00175     }
00176 
00177     template <typename T>
00178     bool
00179     AutHandler<T>::end ()
00180     {
00181       return end_;
00182     }
00183 
00184     /*
00185      * TypeHandler
00186      */
00187     template <typename T>
00188     TypeHandler<T>::TypeHandler (xercesc::DefaultHandler& root,
00189                                  T& aut,
00190                                  xercesc::SAX2XMLReader* parser,
00191                                  XMLEq& eq)
00192       : Handler(parser, eq, root),
00193         aut_(aut)
00194     {
00195     }
00196 
00197     template <typename T>
00198     void
00199     TypeHandler<T>::startElement (const XMLCh* const,
00200                                   const XMLCh* const localname,
00201                                   const XMLCh* const,
00202                                   const xercesc::Attributes& attrs)
00203     {
00204       using namespace xercesc;
00205       // Possible optimisation :
00206       // - using a simple boolean better than a comparison
00207       if (XMLString::equals(eq_.monoid, localname))
00208       {
00209         monoid_ = builders::create_monoid(aut_, attrs);
00210         monoidh_ = builders::monoidh_factory(*monoid_, attrs, *this, parser_, eq_);
00211         parser_->setContentHandler(monoidh_);
00212       }
00213       else // <semiring>, <numericalSemiring>
00214       {
00215         // Attach the alphabet to the autmaton
00216         series_set_t    series(aut_.structure().series().semiring(), *monoid_);
00217         aut_.attach(series);
00218 
00219         // parse semiring
00220         semiring_ = builders::create_semiring(aut_, attrs);
00221         semiringh_ = builders::semiringh_factory(aut_, attrs, *semiring_, *this, parser_, eq_);
00222         parser_->setContentHandler(semiringh_);
00223       }
00224     }
00225 
00226     template <typename T>
00227     void
00228     TypeHandler<T>::endElement (const XMLCh* const,
00229                                 const XMLCh* const localname,
00230                                 const XMLCh* const)
00231     {
00232       using namespace xercesc;
00233 
00234       // Attach the semiring to the automaton
00235       series_set_t      series(*semiring_, aut_.structure().series().monoid());
00236       aut_.attach(series);
00237 
00238       delete semiringh_;
00239       delete monoidh_;
00240       delete semiring_;
00241       delete monoid_;
00242       if (XMLString::equals(eq_.type, localname))
00243         parser_->setContentHandler(&root_);
00244   } // !xml
00245 
00246     /*
00247      * MonoidHandler
00248      */
00249     MonoidHandler::MonoidHandler (xercesc::DefaultHandler& root,
00250                                   xercesc::SAX2XMLReader* parser,
00251                                   XMLEq& eq)
00252       : Handler(parser, eq, root)
00253     {
00254     }
00255 
00256     /*
00257      * FreeMonoidHandler
00258      */
00259     template <typename T>
00260     FreeMonoidHandler<T>::FreeMonoidHandler (xercesc::DefaultHandler& root,
00261                                              T& monoid,
00262                                              xercesc::SAX2XMLReader* parser,
00263                                              XMLEq& eq)
00264       : MonoidHandler(root, parser, eq),
00265         monoid_(monoid)
00266     {
00267     }
00268 
00269     template <typename T>
00270     void
00271     FreeMonoidHandler<T>::startElement (const XMLCh* const,
00272                                         const XMLCh* const,
00273                                         const XMLCh* const,
00274                                         const xercesc::Attributes& attrs)
00275     {
00276       // Should necessary be a <generator> tag
00277       const XMLCh* value = builders::get_attribute(attrs, "value");
00278       std::string letter = xml2str(value);
00279       builders::insert_letter(monoid_, letter);
00280     }
00281 
00282     template <typename T>
00283     void
00284     FreeMonoidHandler<T>::endElement (const XMLCh* const,
00285                                       const XMLCh* const localname,
00286                                       const XMLCh* const)
00287     {
00288       if (xercesc::XMLString::equals(eq_.monoid, localname))
00289         parser_->setContentHandler(&root_);
00290     }
00291     /*
00292      * ProdMonoidHandler
00293      */
00294     template <typename T>
00295     ProdMonoidHandler<T>::ProdMonoidHandler (xercesc::DefaultHandler& root,
00296                                              T& monoid,
00297                                              xercesc::SAX2XMLReader* parser,
00298                                              XMLEq& eq)
00299       : MonoidHandler(root, parser, eq),
00300         monoid_(monoid),
00301         first_(true)
00302     {
00303     }
00304 
00305     template <typename T>
00306     void
00307     ProdMonoidHandler<T>::startElement (const XMLCh* const,
00308                                         const XMLCh* const,
00309                                         const XMLCh* const,
00310                                         const xercesc::Attributes& attrs)
00311     {
00312       if (first_)
00313       {
00314         monoidh_ = builders::monoidh_factory(monoid_.first_monoid(), attrs, *this, parser_, eq_);
00315         first_ = false;
00316       }
00317       else
00318       {
00319         delete monoidh_;
00320         monoidh_ = builders::monoidh_factory(monoid_.second_monoid(), attrs, *this, parser_, eq_);
00321       }
00322       parser_->setContentHandler(monoidh_);
00323     }
00324 
00325     template <typename T>
00326     void
00327     ProdMonoidHandler<T>::endElement (const XMLCh* const,
00328                                       const XMLCh* const,
00329                                       const XMLCh* const)
00330     {
00331       delete monoidh_;
00332       parser_->setContentHandler(&root_);
00333     }
00334 
00335     /*
00336      * SemiringHandler
00337      */
00338     SemiringHandler::SemiringHandler (xercesc::DefaultHandler& root,
00339                                       xercesc::SAX2XMLReader* parser,
00340                                       XMLEq& eq)
00341       : Handler(parser, eq, root)
00342     {
00343     }
00344     /*
00345      * SeriesSemiringHandler
00346      */
00347     template <typename T>
00348     SeriesSemiringHandler<T>::SeriesSemiringHandler (xercesc::DefaultHandler& root,
00349                                                      T& semiring,
00350                                                      xercesc::SAX2XMLReader* parser,
00351                                                      XMLEq& eq)
00352       : SemiringHandler(root, parser, eq),
00353         semiring_(semiring)
00354     {
00355     }
00356 
00357     template <typename T>
00358     void
00359     SeriesSemiringHandler<T>::startElement (const XMLCh* const,
00360                                             const XMLCh* const localname,
00361                                             const XMLCh* const,
00362                                             const xercesc::Attributes& attrs)
00363     {
00364       using namespace xercesc;
00365 
00366       if (XMLString::equals(eq_.monoid, localname))
00367       {
00368         monoidh_ = builders::monoidh_factory(const_cast
00369                                              <typename T::monoid_t&>
00370                                              (semiring_.monoid()), attrs, *this, parser_, eq_);
00371         parser_->setContentHandler(monoidh_);
00372       }
00373       else
00374       {
00375         semiringh_ = builders::semiringh_factory(semiring_, attrs, semiring_.semiring(),
00376                                                  *this, parser_, eq_);
00377         parser_->setContentHandler(semiringh_);
00378       }
00379     }
00380 
00381     template <typename T>
00382     void
00383     SeriesSemiringHandler<T>::endElement (const XMLCh* const,
00384                                           const XMLCh* const,
00385                                           const XMLCh* const)
00386     {
00387       delete monoidh_;
00388       delete semiringh_;
00389       parser_->setContentHandler(&root_);
00390     }
00391     /*
00392      * NumSemiringHandler
00393      */
00394     template <typename T>
00395     NumSemiringHandler<T>::NumSemiringHandler (xercesc::DefaultHandler& root,
00396                                                T& semiring,
00397                                                xercesc::SAX2XMLReader* parser,
00398                                                XMLEq& eq)
00399       : SemiringHandler(root, parser, eq),
00400         semiring_(semiring)
00401     {
00402     }
00403 
00404     template <typename T>
00405     void
00406     NumSemiringHandler<T>::startElement (const XMLCh* const,
00407                                             const XMLCh* const,
00408                                             const XMLCh* const,
00409                                             const xercesc::Attributes&)
00410     {
00411     }
00412 
00413     template <typename T>
00414     void
00415     NumSemiringHandler<T>::endElement (const XMLCh* const,
00416                                           const XMLCh* const,
00417                                           const XMLCh* const)
00418     {
00419       parser_->setContentHandler(&root_);
00420     }
00421 
00422     /*
00423      * ContentHandler
00424      */
00425     template <typename T>
00426     ContHandler<T>::ContHandler (xercesc::DefaultHandler& root,
00427                                  T& aut,
00428                                  xercesc::SAX2XMLReader* parser,
00429                                  XMLEq& eq)
00430       : Handler(parser, eq, root),
00431         aut_(aut),
00432         transh_(*this, aut, map_, parser, eq),
00433         statesh_(*this, aut, map_, parser, eq)
00434     {
00435     }
00436 
00437     template <typename T>
00438     void
00439     ContHandler<T>::startElement (const XMLCh* const,
00440                                   const XMLCh* const localname,
00441                                   const XMLCh* const,
00442                                   const xercesc::Attributes&)
00443     {
00444       using namespace xercesc;
00445 
00446       // Possible optimisation :
00447       // - using a simple boolean better than a comparaison
00448       if (XMLString::equals(eq_.states, localname))
00449         parser_->setContentHandler(&statesh_);
00450       else
00451         parser_->setContentHandler(&transh_);
00452     }
00453 
00454     template <typename T>
00455     void
00456     ContHandler<T>::endElement (const XMLCh* const,
00457                                 const XMLCh* const,
00458                                 const XMLCh* const)
00459     {
00460       parser_->setContentHandler(&root_);
00461     }
00462 
00463     /*
00464      * StatesHandler
00465      */
00466     template <typename T>
00467     StatesHandler<T>::StatesHandler (xercesc::DefaultHandler& root,
00468                                      T& aut,
00469                                      map_t& map,
00470                                      xercesc::SAX2XMLReader* parser,
00471                                      XMLEq& eq)
00472       : Handler(parser, eq, root),
00473         map_(map),
00474         aut_(aut),
00475         stateh_(*this, map_, parser, eq)
00476     {
00477     }
00478 
00479     template <typename T>
00480     void
00481     StatesHandler<T>::startElement (const XMLCh* const,
00482                                     const XMLCh* const,
00483                                     const XMLCh* const,
00484                                     const xercesc::Attributes& attrs)
00485     {
00486       hstate_t state = aut_.add_state();
00487       map_[xml2str(builders::get_attribute(attrs, "name"))] = state;
00488 
00489       stateh_.reset(&state);
00490       parser_->setContentHandler(&stateh_);
00491     }
00492 
00493     template <typename T>
00494     void
00495     StatesHandler<T>::endElement (const XMLCh* const,
00496                                   const XMLCh* const,
00497                                   const XMLCh* const)
00498     {
00499       parser_->setContentHandler(&root_);
00500     }
00501 
00502     /*
00503      * StateHandler
00504      */
00505     template <typename T>
00506     StateHandler<T>::StateHandler (xercesc::DefaultHandler& root,
00507                                    map_t& map,
00508                                    xercesc::SAX2XMLReader* parser,
00509                                    XMLEq& eq)
00510       : Handler(parser, eq, root),
00511         map_(map),
00512         unsuph_(*this, parser)
00513     {
00514     }
00515 
00516     template <typename T>
00517     void
00518     StateHandler<T>::startElement (const XMLCh* const,
00519                                    const XMLCh* const,
00520                                    const XMLCh* const,
00521                                    const xercesc::Attributes&)
00522     {
00523       // geometry / drawing
00524       parser_->setContentHandler(&unsuph_);
00525     }
00526 
00527     template <typename T>
00528     void
00529     StateHandler<T>::endElement (const XMLCh* const,
00530                                  const XMLCh* const localname,
00531                                  const XMLCh* const)
00532     {
00533       if (xercesc::XMLString::equals(eq_.state, localname))
00534         parser_->setContentHandler(&root_);
00535     }
00536 
00537     template <typename T>
00538     void
00539     StateHandler<T>::reset (hstate_t* state)
00540     {
00541       state_ = state;
00542     }
00543 
00544     /*
00545      * RegExpHandler
00546      */
00547     template <typename T>
00548     RegExpHandler<T>::RegExpHandler (xercesc::DefaultHandler& root,
00549                                      T& aut,
00550                                      xercesc::SAX2XMLReader* parser,
00551                                      XMLEq& eq)
00552       : Handler(parser, eq, root),
00553         aut_(aut),
00554         krat_exp_(aut.structure().series())
00555     {
00556     }
00557 
00558     template <typename T>
00559     typename RegExpHandler<T>::series_set_elt_t
00560     RegExpHandler<T>::get_series()
00561     {
00562       return krat_exp_;
00563     }
00564 
00565     template <typename T>
00566     SumHandler<T>::SumHandler (xercesc::DefaultHandler& root,
00567                                T& aut,
00568                                xercesc::SAX2XMLReader* parser,
00569                                XMLEq& eq)
00570       : RegExpHandler<T>(root, aut, parser, eq),
00571         first_(true)
00572     {
00573     }
00574     template <typename T>
00575     void
00576     SumHandler<T>::startElement (const XMLCh* const,
00577                                  const XMLCh* const localname,
00578                                  const XMLCh* const,
00579                                  const xercesc::Attributes& attrs)
00580     {
00581       if (first_)
00582       {
00583         lefth_ = builders::labelh_factory(*this, this->aut_,
00584                                           this->parser_, this->eq_,
00585                                           localname, attrs);
00586         this->parser_->setContentHandler(lefth_);
00587       }
00588       else
00589       {
00590         righth_ = builders::labelh_factory(*this, this->aut_,
00591                                           this->parser_, this->eq_,
00592                                           localname, attrs);
00593         this->parser_->setContentHandler(righth_);
00594       }
00595       first_ = false;
00596     }
00597     template <typename T>
00598     void
00599     SumHandler<T>::endElement (const XMLCh* const,
00600                                const XMLCh* const,
00601                                const XMLCh* const)
00602     {
00603       this->krat_exp_ = lefth_->get_series() + righth_->get_series();
00604       this->parser_->setContentHandler(&this->root_);
00605       delete lefth_;
00606       delete righth_;
00607     }
00608 
00609     template <typename T>
00610     ProdHandler<T>::ProdHandler (xercesc::DefaultHandler& root,
00611                                  T& aut,
00612                                  xercesc::SAX2XMLReader* parser,
00613                                  XMLEq& eq)
00614       : RegExpHandler<T>(root, aut, parser, eq),
00615         first_(true)
00616     {
00617     }
00618     template <typename T>
00619     void
00620     ProdHandler<T>::startElement (const XMLCh* const,
00621                                   const XMLCh* const localname,
00622                                   const XMLCh* const,
00623                                   const xercesc::Attributes& attrs)
00624     {
00625       if (first_)
00626       {
00627         lefth_ = builders::labelh_factory(*this, this->aut_,
00628                                           this->parser_, this->eq_,
00629                                           localname, attrs);
00630         this->parser_->setContentHandler(lefth_);
00631       }
00632       else
00633       {
00634         righth_ = builders::labelh_factory(*this, this->aut_,
00635                                           this->parser_, this->eq_,
00636                                           localname, attrs);
00637         this->parser_->setContentHandler(righth_);
00638       }
00639       first_ = false;
00640     }
00641     template <typename T>
00642     void
00643     ProdHandler<T>::endElement (const XMLCh* const,
00644                                 const XMLCh* const,
00645                                 const XMLCh* const)
00646     {
00647       this->krat_exp_ = lefth_->get_series() * righth_->get_series();
00648       this->parser_->setContentHandler(&this->root_);
00649       delete lefth_;
00650       delete righth_;
00651     }
00652 
00653     template <typename T>
00654     StarHandler<T>::StarHandler (xercesc::DefaultHandler& root,
00655                                  T& aut,
00656                                  xercesc::SAX2XMLReader* parser,
00657                                  XMLEq& eq)
00658       : RegExpHandler<T>(root, aut, parser, eq)
00659     {
00660     }
00661     template <typename T>
00662     void
00663     StarHandler<T>::startElement (const XMLCh* const,
00664                                   const XMLCh* const localname,
00665                                   const XMLCh* const,
00666                                   const xercesc::Attributes& attrs)
00667     {
00668       sonh_ = builders::labelh_factory(*this, this->aut_,
00669                                        this->parser_, this->eq_,
00670                                        localname, attrs);
00671       this->parser_->setContentHandler(sonh_);
00672     }
00673     template <typename T>
00674     void
00675     StarHandler<T>::endElement (const XMLCh* const,
00676                                 const XMLCh* const,
00677                                 const XMLCh* const)
00678     {
00679       this->krat_exp_ = sonh_->get_series().star();
00680       this->parser_->setContentHandler(&this->root_);
00681       delete sonh_;
00682     }
00683 
00684     template <typename T>
00685     WordHandler<T>::WordHandler (xercesc::DefaultHandler& root,
00686                                  T& aut,
00687                                  xercesc::SAX2XMLReader* parser,
00688                                  XMLEq& eq,
00689                                  typename RegExpHandler<T>::series_set_elt_t val)
00690       : RegExpHandler<T>(root, aut, parser, eq)
00691     {
00692       this->krat_exp_ = val;
00693     }
00694     template <typename T>
00695     void
00696     WordHandler<T>::startElement (const XMLCh* const,
00697                                   const XMLCh* const,
00698                                   const XMLCh* const,
00699                                   const xercesc::Attributes&)
00700     {
00701     }
00702     template <typename T>
00703     void
00704     WordHandler<T>::endElement (const XMLCh* const,
00705                                 const XMLCh* const,
00706                                 const XMLCh* const)
00707     {
00708       this->parser_->setContentHandler(&this->root_);
00709     }
00710     template <typename T>
00711     LabelHandler<T>::LabelHandler (xercesc::DefaultHandler& root,
00712                                    T& aut,
00713                                    xercesc::SAX2XMLReader* parser,
00714                                    XMLEq& eq)
00715       : RegExpHandler<T>(root, aut, parser, eq),
00716         used_(false)
00717     {
00718     }
00719     template <typename T>
00720     void
00721     LabelHandler<T>::startElement (const XMLCh* const,
00722                                    const XMLCh* const localname,
00723                                    const XMLCh* const,
00724                                    const xercesc::Attributes& attrs)
00725     {
00726       used_ = true;
00727       sonh_ = builders::labelh_factory(*this, this->aut_,
00728                                        this->parser_, this->eq_,
00729                                        localname, attrs);
00730       this->parser_->setContentHandler(sonh_);
00731     }
00732     template <typename T>
00733     void
00734     LabelHandler<T>::endElement (const XMLCh* const,
00735                                  const XMLCh* const,
00736                                  const XMLCh* const)
00737     {
00738       this->krat_exp_ = sonh_->get_series();
00739       this->parser_->setContentHandler(&this->root_);
00740     }
00741     template <typename T>
00742     bool
00743     LabelHandler<T>::used ()
00744     {
00745       return used_;
00746     }
00747     template <typename T>
00748     void
00749     LabelHandler<T>::reset ()
00750     {
00751       used_ = false;
00752       this->krat_exp_ = typename RegExpHandler<T>::series_set_elt_t(this->aut_.structure().series());
00753     }
00754 
00755     template <typename T>
00756     typename LabelHandler<T>::series_set_elt_t
00757     LabelHandler<T>::value ()
00758     {
00759       return this->krat_exp_;
00760     }
00761 
00762     /*
00763      * TransitionsHandler
00764      */
00765     template <typename T>
00766     TransitionsHandler<T>::TransitionsHandler (xercesc::DefaultHandler& root,
00767                                                T& aut,
00768                                                map_t& map,
00769                                                xercesc::SAX2XMLReader* parser,
00770                                                XMLEq& eq)
00771       : Handler(parser, eq, root),
00772         map_(map),
00773         aut_(aut),
00774         transh_(*this, aut, map, curattrs_, parser, eq)
00775     {
00776     }
00777 
00778     template <typename T>
00779     TransitionsHandler<T>::~TransitionsHandler()
00780     {
00781     }
00782 
00783     template <typename T>
00784     void
00785     TransitionsHandler<T>::startElement (const XMLCh* const,
00786                                          const XMLCh* const,
00787                                          const XMLCh* const,
00788                                          const xercesc::Attributes& attrs)
00789     {
00790       curattrs_.clear();
00791       for (unsigned int i = 0; i < attrs.getLength(); i++)
00792         curattrs_[xml2str(attrs.getLocalName(i))] =  xml2str(attrs.getValue(i));
00793       parser_->setContentHandler(&transh_);
00794     }
00795 
00796     template <typename T>
00797     void
00798     TransitionsHandler<T>::endElement (const XMLCh* const,
00799                                        const XMLCh* const,
00800                                        const XMLCh* const)
00801     {
00802       parser_->setContentHandler(&root_);
00803     }
00804 
00805 
00806     /*
00807      * TransitionHandler
00808      */
00809     template <typename T>
00810     TransitionHandler<T>::TransitionHandler (xercesc::DefaultHandler& root,
00811                                              T& aut,
00812                                              map_t& map,
00813                                              curattrs_t& attrs,
00814                                              xercesc::SAX2XMLReader* parser,
00815                                              XMLEq& eq)
00816       : Handler(parser, eq, root),
00817         attrs_(attrs),
00818         map_(map),
00819         aut_(aut),
00820         unsuph_(*this, parser),
00821         labelh_(*this, aut, parser, eq)
00822     {
00823     }
00824 
00825     template <typename T>
00826     void
00827     TransitionHandler<T>::startElement (const XMLCh* const,
00828                                         const XMLCh* const localname,
00829                                         const XMLCh* const,
00830                                         const xercesc::Attributes&)
00831     {
00832       if (xercesc::XMLString::equals(eq_.label, localname))
00833         parser_->setContentHandler(&labelh_);
00834       else
00835         if (xercesc::XMLString::equals(eq_.drawing, localname))
00836           parser_->setContentHandler(&unsuph_);
00837         else
00838           if (xercesc::XMLString::equals(eq_.geometry, localname))
00839             parser_->setContentHandler(&unsuph_);
00840     }
00841 
00842     template <typename T>
00843     TransitionHandler<T>::~TransitionHandler ()
00844     {
00845     }
00846 
00847     template <typename T>
00848     void
00849     TransitionHandler<T>::endElement (const XMLCh* const,
00850                                       const XMLCh* const localname,
00851                                       const XMLCh* const)
00852     {
00853       if (xercesc::XMLString::equals(eq_.transition, localname))
00854       {
00855         typename T::series_set_elt_t s =
00856           builders::get_series_transition(aut_, attrs_, labelh_);
00857 
00858         // no checks are made because the xsd ensure the existence of these keys
00859         hstate_t src = map_[attrs_["src"]];
00860         hstate_t dst = map_[attrs_["dst"]];
00861         typename T::htransition_t e = aut_.add_series_transition(src, dst, s);
00862       }
00863       else // tag == "initial" || tag == "final"
00864       {
00865         typename T::series_set_elt_t s =
00866           builders::get_series_transition(aut_, attrs_, labelh_);
00867 
00868         // no checks are made because the xsd ensure the existence of this key
00869         hstate_t state = map_[attrs_["state"]];
00870         if (xercesc::XMLString::equals(eq_.initial, localname))
00871           aut_.set_initial(state, s);
00872         else // tag == "final"
00873           aut_.set_final(state, s);
00874       }
00875       labelh_.reset();
00876       parser_->setContentHandler(&root_);
00877     }
00878   } // !xml
00879 } // !vcsn
00880 
00881 #endif /* !HANDLERS_HXX */