00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #ifndef VCSN_XML_HANDLERS_HXX
00019 # define VCSN_XML_HANDLERS_HXX
00020
00021 # include <xercesc/util/XMLString.hpp>
00022
00023 # include <vaucanson/xml/tools.hh>
00024
00025 namespace vcsn
00026 {
00027 namespace xml
00028 {
00029
00030
00031
00032 template <typename T>
00033 DocHandler<T>::DocHandler (xercesc::SAX2XMLReader* parser,
00034 xercesc::DefaultHandler& root,
00035 T& aut,
00036 XMLEq& eq)
00037 : Handler(parser, root, eq),
00038 aut_(aut),
00039 auth_(parser, *this, aut)
00040 {
00041 }
00042
00043 template <typename T>
00044 void
00045 DocHandler<T>::start (const XMLCh* const,
00046 const XMLCh* const localname,
00047 const XMLCh* const,
00048 const xercesc::Attributes&)
00049 {
00050 using namespace xercesc;
00051 if (XMLString::equals(eq_.fsmxml, localname))
00052 {
00053
00054
00055 parser_->setContentHandler(&auth_);
00056 }
00057 else
00058 error::token(localname);
00059 }
00060
00061 template <typename T>
00062 void
00063 DocHandler<T>::end (const XMLCh* const,
00064 const XMLCh* const,
00065 const XMLCh* const)
00066 {
00067 }
00068
00072 template <typename T>
00073 AutHandler<T>::AutHandler (xercesc::SAX2XMLReader* parser,
00074 Handler& root,
00075 T& aut)
00076 : Handler(parser, root),
00077 aut_(aut),
00078 typeh_(parser, *this, aut),
00079 contenth_(parser, *this, aut),
00080 unsuph_(parser, *this)
00081 {
00082 }
00083
00084 template <typename T>
00085 void
00086 AutHandler<T>::start (const XMLCh* const uri,
00087 const XMLCh* const localname,
00088 const XMLCh* const,
00089 const xercesc::Attributes& attrs)
00090 {
00091 using namespace xercesc;
00092 if (XMLString::equals(eq_.automaton, localname))
00093 {
00094 const XMLCh* autname = tools::get_attribute(attrs, "name", uri);
00095 if (autname != 0)
00096 aut_.geometry().name() = xmlstr(autname);
00097
00098 }
00099 else if (XMLString::equals(eq_.drawing, localname))
00100 parser_->setContentHandler(&unsuph_);
00101 else if (XMLString::equals(eq_.geometry, localname))
00102 parser_->setContentHandler(&unsuph_);
00103 else if (XMLString::equals(eq_.valueType, localname))
00104 parser_->setContentHandler(&typeh_);
00105 else if (XMLString::equals(eq_.content, localname))
00106 parser_->setContentHandler(&contenth_);
00107 else
00108 error::token(localname);
00109 }
00110
00111 template <typename T>
00112 void
00113 AutHandler<T>::end (const XMLCh* const,
00114 const XMLCh* const localname,
00115 const XMLCh* const)
00116 {
00117 using namespace xercesc;
00118 if (XMLString::equals(eq_.automaton, localname))
00119 parser_->setContentHandler(&root_);
00120 }
00121
00125 template <typename T>
00126 TypeHandler<T>::TypeHandler (xercesc::SAX2XMLReader* parser,
00127 Handler& root,
00128 T& param)
00129 : Handler(parser, root),
00130 monoid_(0),
00131 semiring_(0),
00132 rep_(0),
00133 param_(param),
00134 monoidh_(0),
00135 reph_(0),
00136 semiringh_(0),
00137 unsuph_(parser, *this)
00138 {
00139 }
00140
00141 template <typename T>
00142 void
00143 TypeHandler<T>::start(const XMLCh* const,
00144 const XMLCh* const localname,
00145 const XMLCh* const,
00146 const xercesc::Attributes& attrs)
00147 {
00148 using namespace xercesc;
00149
00150 if (XMLString::equals(eq_.semiring, localname))
00151 {
00152 semiring_ = builders::create_semiring(param_, localname, attrs);
00153 semiringh_ = builders::create_semiringh(*semiring_, attrs, parser_, *this);
00154 parser_->setContentHandler(semiringh_);
00155 }
00156 else if (XMLString::equals(eq_.monoid, localname))
00157 {
00158 monoid_ = builders::create_monoid(param_, localname, attrs, eq_);
00159 monoidh_ = builders::create_monoidh(*monoid_, attrs, parser_, *this);
00160 parser_->setContentHandler(monoidh_);
00161 }
00162 else if (XMLString::equals(eq_.writingData, localname))
00163 {
00164 rep_ = builders::create_series_representation(param_, localname, attrs, eq_);
00165 reph_ = builders::create_series_representationh(*rep_, attrs, parser_, *this, eq_);
00166 parser_->setContentHandler(reph_);
00167 }
00168 else
00169 error::token(localname);
00170 }
00171
00172 template <typename T>
00173 void
00174 TypeHandler<T>::end(const XMLCh* const,
00175 const XMLCh* const localname,
00176 const XMLCh* const)
00177 {
00178 using namespace xercesc;
00179
00180
00181
00182 if (rep_)
00183 {
00184 typename T::series_set_t series(*semiring_, *monoid_, *rep_);
00185 param_.attach(series);
00186 }
00187 else
00188 {
00189 typename T::series_set_t series(*semiring_, *monoid_);
00190 param_.attach(series);
00191 }
00192
00193 if (XMLString::equals(eq_.valueType, localname))
00194 parser_->setContentHandler(&root_);
00195
00196 delete monoid_;
00197 delete monoidh_;
00198 delete rep_;
00199 delete reph_;
00200 delete semiring_;
00201 delete semiringh_;
00202 }
00203
00207 template <typename T>
00208 ContHandler<T>::ContHandler (xercesc::SAX2XMLReader* parser,
00209 Handler& root,
00210 T& aut)
00211 : Handler(parser, root),
00212 aut_(aut),
00213 statesh_(parser, *this, aut, map_),
00214 transitionsh_(parser, *this, aut, map_)
00215 {
00216 }
00217
00218 template <typename T>
00219 void
00220 ContHandler<T>::start (const XMLCh* const,
00221 const XMLCh* const localname,
00222 const XMLCh* const,
00223 const xercesc::Attributes&)
00224 {
00225 using namespace xercesc;
00226 if (XMLString::equals(eq_.states, localname))
00227 parser_->setContentHandler(&statesh_);
00228 else if (XMLString::equals(eq_.transitions, localname))
00229 parser_->setContentHandler(&transitionsh_);
00230 else
00231 error::token(localname);
00232 }
00233
00234 template <typename T>
00235 void
00236 ContHandler<T>::end (const XMLCh* const,
00237 const XMLCh* const localname,
00238 const XMLCh* const)
00239 {
00240 using namespace xercesc;
00241 if (XMLString::equals(eq_.content, localname))
00242 parser_->setContentHandler(&root_);
00243 else
00244 error::token(localname);
00245 }
00246
00250 template <typename T>
00251 StatesHandler<T>::StatesHandler (xercesc::SAX2XMLReader* parser,
00252 Handler& root,
00253 T& aut,
00254 map_t& map)
00255 : Handler(parser, root),
00256 aut_(aut),
00257 map_(map),
00258 stateh_(0)
00259 {
00260 }
00261
00262 template <typename T>
00263 void
00264 StatesHandler<T>::start (const XMLCh* const,
00265 const XMLCh* const localname,
00266 const XMLCh* const,
00267 const xercesc::Attributes& attrs)
00268 {
00269 using namespace xercesc;
00270 if (XMLString::equals(eq_.state, localname))
00271 {
00272 hstate_t state = aut_.add_state();
00273 map_[xmlstr(tools::get_attribute(attrs, eq_.id))] = state;
00274 delete stateh_;
00275 stateh_ = new StateHandler<T>(parser_, *this, aut_, state);
00276 parser_->setContentHandler(stateh_);
00277 }
00278 else
00279 error::token(localname);
00280 }
00281
00282 template <typename T>
00283 void
00284 StatesHandler<T>::end (const XMLCh* const,
00285 const XMLCh* const localname,
00286 const XMLCh* const)
00287 {
00288 using namespace xercesc;
00289 if (XMLString::equals(eq_.states, localname))
00290 parser_->setContentHandler(&root_);
00291 else
00292 error::token(localname);
00293 delete stateh_;
00294 }
00295
00299 template <typename T>
00300 StateHandler<T>::StateHandler (xercesc::SAX2XMLReader* parser,
00301 Handler& root,
00302 T& aut,
00303 hstate_t state)
00304 : Handler(parser, root),
00305 aut_(aut),
00306 state_(state),
00307 geometryh_(parser, *this, aut, state),
00308 unsuph_(parser, *this)
00309 {
00310 }
00311
00312 template <typename T>
00313 void
00314 StateHandler<T>::start (const XMLCh* const,
00315 const XMLCh* const localname,
00316 const XMLCh* const,
00317 const xercesc::Attributes& attrs)
00318 {
00319 using namespace xercesc;
00320 if (XMLString::equals(eq_.drawing, localname))
00321 parser_->setContentHandler(&unsuph_);
00322 else if (XMLString::equals(eq_.geometry, localname))
00323 {
00324 typedef typename T::geometry_t::states_geometry_map_t gmap_t;
00325
00326 double y = 0;
00327 double x = 0;
00328 if (tools::has_attribute(attrs, eq_.x))
00329 {
00330 std::istringstream xstr(xmlstr(tools::get_attribute(attrs, eq_.x)));
00331 xstr >> x;
00332 }
00333 if (tools::has_attribute(attrs, eq_.y))
00334 {
00335 std::istringstream ystr(xmlstr(tools::get_attribute(attrs, eq_.y)));
00336 ystr >> y;
00337 }
00338 gmap_t& map = aut_.geometry().states();
00339 map[state_] = std::make_pair(x,y);
00340 parser_->setContentHandler(&geometryh_);
00341 }
00342 else
00343 error::token(localname);
00344 }
00345
00346 template <typename T>
00347 void
00348 StateHandler<T>::end (const XMLCh* const,
00349 const XMLCh* const localname,
00350 const XMLCh* const)
00351 {
00352 using namespace xercesc;
00353 if (XMLString::equals(eq_.state, localname))
00354 parser_->setContentHandler(&root_);
00355 else
00356 error::token(localname);
00357 }
00358
00362 template <typename T>
00363 TransitionsHandler<T>::TransitionsHandler (xercesc::SAX2XMLReader* parser,
00364 Handler& root,
00365 T& aut,
00366 map_t& map)
00367 : Handler(parser, root),
00368 aut_(aut),
00369 map_(map),
00370 transitionh_(0)
00371 {
00372 }
00373
00374 template <typename T>
00375 void
00376 TransitionsHandler<T>::start (const XMLCh* const,
00377 const XMLCh* const localname,
00378 const XMLCh* const,
00379 const xercesc::Attributes& attrs)
00380 {
00381 using namespace xercesc;
00382 if (XMLString::equals(eq_.transition, localname))
00383 {
00384 hstate_t src = map_[xmlstr(tools::get_attribute(attrs, eq_.source))];
00385 hstate_t dst = map_[xmlstr(tools::get_attribute(attrs, eq_.target))];
00386 delete transitionh_;
00387 transitionh_ = new TransitionHandler<T>(parser_, *this, aut_, src, dst);
00388 parser_->setContentHandler(transitionh_);
00389 }
00390 else if (XMLString::equals(eq_.final, localname))
00391 {
00392 hstate_t state = map_[xmlstr(tools::get_attribute(attrs, eq_.state))];
00393 delete transitionh_;
00394 transitionh_ = new InitFinalHandler<T>(parser_, *this, aut_, state, false);
00395 parser_->setContentHandler(transitionh_);
00396 }
00397 else if (XMLString::equals(eq_.initial, localname))
00398 {
00399 hstate_t state = map_[xmlstr(tools::get_attribute(attrs, eq_.state))];
00400 delete transitionh_;
00401 transitionh_ = new InitFinalHandler<T>(parser_, *this, aut_, state, true);
00402 parser_->setContentHandler(transitionh_);
00403 }
00404 else
00405 error::token(localname);
00406 }
00407
00408 template <typename T>
00409 void
00410 TransitionsHandler<T>::end (const XMLCh* const,
00411 const XMLCh* const localname,
00412 const XMLCh* const)
00413 {
00414 using namespace xercesc;
00415 if (XMLString::equals(eq_.transitions, localname))
00416 parser_->setContentHandler(&root_);
00417 else
00418 error::token(localname);
00419 delete transitionh_;
00420 }
00421
00425 template <typename T>
00426 TransitionHandler<T>::TransitionHandler (xercesc::SAX2XMLReader* parser,
00427 Handler& root,
00428 T& aut,
00429 hstate_t src,
00430 hstate_t dst)
00431 : Handler(parser, root),
00432 aut_(aut),
00433 src_(src),
00434 dst_(dst),
00435 s_(aut.structure().series()),
00436 labelh_(parser, *this, s_, eq_.label),
00437 unsuph_(parser, *this)
00438 {
00439 }
00440
00441 template <typename T>
00442 void
00443 TransitionHandler<T>::start (const XMLCh* const,
00444 const XMLCh* const localname,
00445 const XMLCh* const,
00446 const xercesc::Attributes&)
00447 {
00448 using namespace xercesc;
00449 if (XMLString::equals(eq_.drawing, localname))
00450 parser_->setContentHandler(&unsuph_);
00451 else if (XMLString::equals(eq_.geometry, localname))
00452 parser_->setContentHandler(&unsuph_);
00453 else if (XMLString::equals(eq_.label, localname))
00454 parser_->setContentHandler(&labelh_);
00455 else
00456 error::token(localname);
00457 }
00458
00459 template <typename T>
00460 void
00461 TransitionHandler<T>::end (const XMLCh* const,
00462 const XMLCh* const localname,
00463 const XMLCh* const)
00464 {
00465 using namespace xercesc;
00466 if (XMLString::equals(eq_.transition, localname))
00467 {
00468 parser_->setContentHandler(&root_);
00469 aut_.add_series_transition(src_, dst_, labelh_.series());
00470 }
00471 else
00472 error::token(localname);
00473 }
00474
00478 template <typename T>
00479 InitFinalHandler<T>::InitFinalHandler (xercesc::SAX2XMLReader* parser,
00480 Handler& root,
00481 T& aut,
00482 hstate_t state,
00483 bool initial)
00484 : Handler(parser, root),
00485 aut_(aut),
00486 state_(state),
00487 initial_(initial),
00488 s_(aut.series().one_),
00489 labelh_(parser, *this, s_, eq_.label),
00490 unsuph_(parser, *this)
00491 {
00492 }
00493
00494 template <typename T>
00495 void
00496 InitFinalHandler<T>::start (const XMLCh* const,
00497 const XMLCh* const localname,
00498 const XMLCh* const,
00499 const xercesc::Attributes&)
00500 {
00501 using namespace xercesc;
00502 if (XMLString::equals(eq_.drawing, localname))
00503 parser_->setContentHandler(&unsuph_);
00504 else if (XMLString::equals(eq_.geometry, localname))
00505 parser_->setContentHandler(&unsuph_);
00506 else if (XMLString::equals(eq_.label, localname))
00507 parser_->setContentHandler(&labelh_);
00508 else
00509 error::token(localname);
00510 }
00511
00512 template <typename T>
00513 void
00514 InitFinalHandler<T>::end (const XMLCh* const,
00515 const XMLCh* const localname,
00516 const XMLCh* const)
00517 {
00518 using namespace xercesc;
00519 if (XMLString::equals(eq_.initial, localname) && initial_)
00520 {
00521 parser_->setContentHandler(&root_);
00522 aut_.set_initial(state_, labelh_.series());
00523 }
00524 else if (XMLString::equals(eq_.final, localname) && !initial_)
00525 {
00526 parser_->setContentHandler(&root_);
00527 aut_.set_final(state_, labelh_.series());
00528 }
00529 else
00530 error::token(localname);
00531 }
00532
00536 template <typename T>
00537 GeometryHandler<T>::GeometryHandler (xercesc::SAX2XMLReader* parser,
00538 Handler& root,
00539 T& aut,
00540 hstate_t state)
00541 : Handler(parser, root),
00542 aut_(aut),
00543 state_(state)
00544 {
00545 }
00546
00547 template <typename T>
00548 void
00549 GeometryHandler<T>::start (const XMLCh* const,
00550 const XMLCh* const localname,
00551 const XMLCh* const,
00552 const xercesc::Attributes&)
00553 {
00554 error::token(localname);
00555 }
00556
00557 template <typename T>
00558 void
00559 GeometryHandler<T>::end (const XMLCh* const,
00560 const XMLCh* const localname,
00561 const XMLCh* const)
00562 {
00563 using namespace xercesc;
00564 if (XMLString::equals(eq_.geometry, localname))
00565 parser_->setContentHandler(&root_);
00566 else
00567 error::token(localname);
00568 }
00569
00573 template <typename T>
00574 RegexpHandler<T>*
00575 RegexpHandler<T>::create (const XMLCh* const localname)
00576 {
00577 using namespace xercesc;
00578 if (XMLString::equals(eq_.monElmt, localname))
00579 return builders::create_monElmth(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()));
00580 else if (XMLString::equals(eq_.star, localname))
00581 return new StarHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()));
00582 else if (XMLString::equals(eq_.leftExtMul, localname))
00583 return new ExtMulHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()), true);
00584 else if (XMLString::equals(eq_.rightExtMul, localname))
00585 return new ExtMulHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()), false);
00586 else if (XMLString::equals(eq_.sum, localname))
00587 return new SumHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()));
00588 else if (XMLString::equals(eq_.product, localname))
00589 return new ProductHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()));
00590 else if (XMLString::equals(eq_.one, localname))
00591 return new AtomHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()), eq_.one);
00592 else if (XMLString::equals(eq_.zero, localname))
00593 return new AtomHandler<T>(parser_, *this, algebra::zero_as<typename T::value_t>::of(param_.structure()), eq_.zero);
00594 else
00595 return 0;
00596 }
00597
00598 template <typename T>
00599 RegexpHandler<T>*
00600 RegexpHandler<T>::create_weight (const xercesc::Attributes& attrs)
00601 {
00602 using namespace xercesc;
00603 return builders::create_weighth(parser_, *this,
00604 algebra::identity_as<typename T::value_t>::of(param_.structure()), attrs);
00605 }
00606 }
00607 }
00608
00609 #endif // !VCSN_XML_HANDLERS_HXX