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 param_(param),
00131 unsuph_(parser, *this)
00132 {
00133 }
00134
00135 template <typename T>
00136 void
00137 TypeHandler<T>::start (const XMLCh* const,
00138 const XMLCh* const localname,
00139 const XMLCh* const,
00140 const xercesc::Attributes& attrs)
00141 {
00142 using namespace xercesc;
00143 if (XMLString::equals(eq_.semiring, localname))
00144 {
00145 semiring_ = builders::create_semiring(param_, localname, attrs);
00146 semiringh_ = builders::create_semiringh(*semiring_, attrs, parser_, *this);
00147 parser_->setContentHandler(semiringh_);
00148 }
00149 else if (XMLString::equals(eq_.monoid, localname))
00150 {
00151 monoid_ = builders::create_monoid(param_, localname, attrs);
00152 monoidh_ = builders::create_monoidh(*monoid_, attrs, parser_, *this);
00153 parser_->setContentHandler(monoidh_);
00154 }
00155 else if (XMLString::equals(eq_.writingData, localname))
00156 {
00157 if (tools::has_attribute(attrs, eq_.openPar))
00158 rep_.open_par = xmlstr(tools::get_attribute(attrs, eq_.openPar));
00159 if (tools::has_attribute(attrs, eq_.closePar))
00160 rep_.close_par = xmlstr(tools::get_attribute(attrs, eq_.closePar));
00161 if (tools::has_attribute(attrs, eq_.plus))
00162 rep_.plus = xmlstr(tools::get_attribute(attrs, eq_.plus));
00163 if (tools::has_attribute(attrs, eq_.times))
00164 rep_.times = xmlstr(tools::get_attribute(attrs, eq_.times));
00165 if (tools::has_attribute(attrs, eq_.star))
00166 rep_.star = xmlstr(tools::get_attribute(attrs, eq_.star));
00167 if (tools::has_attribute(attrs, eq_.zero))
00168 rep_.zero = xmlstr(tools::get_attribute(attrs, eq_.zero));
00169 if (tools::has_attribute(attrs, eq_.openWeight))
00170 rep_.open_weight = xmlstr(tools::get_attribute(attrs, eq_.openWeight));
00171 if (tools::has_attribute(attrs, eq_.closeWeight))
00172 rep_.close_weight = xmlstr(tools::get_attribute(attrs, eq_.closeWeight));
00173 if (tools::has_attribute(attrs, eq_.spaces))
00174 {
00175 rep_.spaces.clear();
00176 rep_.spaces.push_back(xmlstr(tools::get_attribute(attrs, eq_.spaces)));
00177 }
00178 parser_->setContentHandler(&unsuph_);
00179 }
00180 else
00181 error::token(localname);
00182 }
00183
00184 template <typename T>
00185 void
00186 TypeHandler<T>::end (const XMLCh* const,
00187 const XMLCh* const localname,
00188 const XMLCh* const)
00189 {
00190 using namespace xercesc;
00191 typename T::series_set_t series(*semiring_, *monoid_, rep_);
00192 param_.attach(series);
00193
00194 if (XMLString::equals(eq_.valueType, localname))
00195 parser_->setContentHandler(&root_);
00196 delete monoid_;
00197 delete monoidh_;
00198 delete semiring_;
00199 delete semiringh_;
00200 }
00201
00205 template <typename T>
00206 ContHandler<T>::ContHandler (xercesc::SAX2XMLReader* parser,
00207 Handler& root,
00208 T& aut)
00209 : Handler(parser, root),
00210 aut_(aut),
00211 statesh_(parser, *this, aut, map_),
00212 transitionsh_(parser, *this, aut, map_)
00213 {
00214 }
00215
00216 template <typename T>
00217 void
00218 ContHandler<T>::start (const XMLCh* const,
00219 const XMLCh* const localname,
00220 const XMLCh* const,
00221 const xercesc::Attributes&)
00222 {
00223 using namespace xercesc;
00224 if (XMLString::equals(eq_.states, localname))
00225 parser_->setContentHandler(&statesh_);
00226 else if (XMLString::equals(eq_.transitions, localname))
00227 parser_->setContentHandler(&transitionsh_);
00228 else
00229 error::token(localname);
00230 }
00231
00232 template <typename T>
00233 void
00234 ContHandler<T>::end (const XMLCh* const,
00235 const XMLCh* const localname,
00236 const XMLCh* const)
00237 {
00238 using namespace xercesc;
00239 if (XMLString::equals(eq_.content, localname))
00240 parser_->setContentHandler(&root_);
00241 else
00242 error::token(localname);
00243 }
00244
00248 template <typename T>
00249 StatesHandler<T>::StatesHandler (xercesc::SAX2XMLReader* parser,
00250 Handler& root,
00251 T& aut,
00252 map_t& map)
00253 : Handler(parser, root),
00254 aut_(aut),
00255 map_(map),
00256 stateh_(0)
00257 {
00258 }
00259
00260 template <typename T>
00261 void
00262 StatesHandler<T>::start (const XMLCh* const,
00263 const XMLCh* const localname,
00264 const XMLCh* const,
00265 const xercesc::Attributes& attrs)
00266 {
00267 using namespace xercesc;
00268 if (XMLString::equals(eq_.state, localname))
00269 {
00270 hstate_t state = aut_.add_state();
00271 map_[xmlstr(tools::get_attribute(attrs, eq_.id))] = state;
00272 if (stateh_)
00273 delete stateh_;
00274 stateh_ = new StateHandler<T>(parser_, *this, aut_, state);
00275 parser_->setContentHandler(stateh_);
00276 }
00277 else
00278 error::token(localname);
00279 }
00280
00281 template <typename T>
00282 void
00283 StatesHandler<T>::end (const XMLCh* const,
00284 const XMLCh* const localname,
00285 const XMLCh* const)
00286 {
00287 using namespace xercesc;
00288 if (XMLString::equals(eq_.states, localname))
00289 parser_->setContentHandler(&root_);
00290 else
00291 error::token(localname);
00292 if (stateh_)
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 if (transitionh_)
00387 delete transitionh_;
00388 transitionh_ = new TransitionHandler<T>(parser_, *this, aut_, src, dst);
00389 parser_->setContentHandler(transitionh_);
00390 }
00391 else if (XMLString::equals(eq_.final, localname))
00392 {
00393 hstate_t state = map_[xmlstr(tools::get_attribute(attrs, eq_.state))];
00394 if (transitionh_)
00395 delete transitionh_;
00396 transitionh_ = new InitFinalHandler<T>(parser_, *this, aut_, state, false);
00397 parser_->setContentHandler(transitionh_);
00398 }
00399 else if (XMLString::equals(eq_.initial, localname))
00400 {
00401 hstate_t state = map_[xmlstr(tools::get_attribute(attrs, eq_.state))];
00402 if (transitionh_)
00403 delete transitionh_;
00404 transitionh_ = new InitFinalHandler<T>(parser_, *this, aut_, state, true);
00405 parser_->setContentHandler(transitionh_);
00406 }
00407 else
00408 error::token(localname);
00409 }
00410
00411 template <typename T>
00412 void
00413 TransitionsHandler<T>::end (const XMLCh* const,
00414 const XMLCh* const localname,
00415 const XMLCh* const)
00416 {
00417 using namespace xercesc;
00418 if (XMLString::equals(eq_.transitions, localname))
00419 parser_->setContentHandler(&root_);
00420 else
00421 error::token(localname);
00422 if (transitionh_)
00423 delete transitionh_;
00424 }
00425
00429 template <typename T>
00430 TransitionHandler<T>::TransitionHandler (xercesc::SAX2XMLReader* parser,
00431 Handler& root,
00432 T& aut,
00433 hstate_t src,
00434 hstate_t dst)
00435 : Handler(parser, root),
00436 aut_(aut),
00437 src_(src),
00438 dst_(dst),
00439 s_(aut.structure().series()),
00440 labelh_(parser, *this, s_, eq_.label),
00441 unsuph_(parser, *this)
00442 {
00443 }
00444
00445 template <typename T>
00446 void
00447 TransitionHandler<T>::start (const XMLCh* const,
00448 const XMLCh* const localname,
00449 const XMLCh* const,
00450 const xercesc::Attributes&)
00451 {
00452 using namespace xercesc;
00453 if (XMLString::equals(eq_.drawing, localname))
00454 parser_->setContentHandler(&unsuph_);
00455 else if (XMLString::equals(eq_.geometry, localname))
00456 parser_->setContentHandler(&unsuph_);
00457 else if (XMLString::equals(eq_.label, localname))
00458 parser_->setContentHandler(&labelh_);
00459 else
00460 error::token(localname);
00461 }
00462
00463 template <typename T>
00464 void
00465 TransitionHandler<T>::end (const XMLCh* const,
00466 const XMLCh* const localname,
00467 const XMLCh* const)
00468 {
00469 using namespace xercesc;
00470 if (XMLString::equals(eq_.transition, localname))
00471 {
00472 parser_->setContentHandler(&root_);
00473 aut_.add_series_transition(src_, dst_, labelh_.series());
00474 }
00475 else
00476 error::token(localname);
00477 }
00478
00482 template <typename T>
00483 InitFinalHandler<T>::InitFinalHandler (xercesc::SAX2XMLReader* parser,
00484 Handler& root,
00485 T& aut,
00486 hstate_t state,
00487 bool initial)
00488 : Handler(parser, root),
00489 aut_(aut),
00490 state_(state),
00491 initial_(initial),
00492 s_(aut.series().one_),
00493 labelh_(parser, *this, s_, eq_.label),
00494 unsuph_(parser, *this)
00495 {
00496 }
00497
00498 template <typename T>
00499 void
00500 InitFinalHandler<T>::start (const XMLCh* const,
00501 const XMLCh* const localname,
00502 const XMLCh* const,
00503 const xercesc::Attributes&)
00504 {
00505 using namespace xercesc;
00506 if (XMLString::equals(eq_.drawing, localname))
00507 parser_->setContentHandler(&unsuph_);
00508 else if (XMLString::equals(eq_.geometry, localname))
00509 parser_->setContentHandler(&unsuph_);
00510 else if (XMLString::equals(eq_.label, localname))
00511 parser_->setContentHandler(&labelh_);
00512 else
00513 error::token(localname);
00514 }
00515
00516 template <typename T>
00517 void
00518 InitFinalHandler<T>::end (const XMLCh* const,
00519 const XMLCh* const localname,
00520 const XMLCh* const)
00521 {
00522 using namespace xercesc;
00523 if (XMLString::equals(eq_.initial, localname) && initial_)
00524 {
00525 parser_->setContentHandler(&root_);
00526 aut_.set_initial(state_, labelh_.series());
00527 }
00528 else if (XMLString::equals(eq_.final, localname) && !initial_)
00529 {
00530 parser_->setContentHandler(&root_);
00531 aut_.set_final(state_, labelh_.series());
00532 }
00533 else
00534 error::token(localname);
00535 }
00536
00540 template <typename T>
00541 GeometryHandler<T>::GeometryHandler (xercesc::SAX2XMLReader* parser,
00542 Handler& root,
00543 T& aut,
00544 hstate_t state)
00545 : Handler(parser, root),
00546 aut_(aut),
00547 state_(state)
00548 {
00549 }
00550
00551 template <typename T>
00552 void
00553 GeometryHandler<T>::start (const XMLCh* const,
00554 const XMLCh* const localname,
00555 const XMLCh* const,
00556 const xercesc::Attributes&)
00557 {
00558 error::token(localname);
00559 }
00560
00561 template <typename T>
00562 void
00563 GeometryHandler<T>::end (const XMLCh* const,
00564 const XMLCh* const localname,
00565 const XMLCh* const)
00566 {
00567 using namespace xercesc;
00568 if (XMLString::equals(eq_.geometry, localname))
00569 parser_->setContentHandler(&root_);
00570 else
00571 error::token(localname);
00572 }
00573
00577 template <typename T>
00578 RegexpHandler<T>*
00579 RegexpHandler<T>::create (const XMLCh* const localname)
00580 {
00581 using namespace xercesc;
00582 if (XMLString::equals(eq_.monElmt, localname))
00583 return builders::create_monElmth(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()));
00584 else if (XMLString::equals(eq_.star, localname))
00585 return new StarHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()));
00586 else if (XMLString::equals(eq_.leftExtMul, localname))
00587 return new ExtMulHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()), true);
00588 else if (XMLString::equals(eq_.rightExtMul, localname))
00589 return new ExtMulHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()), false);
00590 else if (XMLString::equals(eq_.sum, localname))
00591 return new SumHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()));
00592 else if (XMLString::equals(eq_.product, localname))
00593 return new ProductHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()));
00594 else if (XMLString::equals(eq_.one, localname))
00595 return new AtomHandler<T>(parser_, *this, algebra::identity_as<typename T::value_t>::of(param_.structure()), eq_.one);
00596 else if (XMLString::equals(eq_.zero, localname))
00597 return new AtomHandler<T>(parser_, *this, algebra::zero_as<typename T::value_t>::of(param_.structure()), eq_.zero);
00598 else
00599 return 0;
00600 }
00601
00602 template <typename T>
00603 RegexpHandler<T>*
00604 RegexpHandler<T>::create_weight (const xercesc::Attributes& attrs)
00605 {
00606 using namespace xercesc;
00607 return builders::create_weighth(parser_, *this,
00608 algebra::identity_as<typename T::value_t>::of(param_.structure()), attrs);
00609 }
00610 }
00611 }
00612
00613 #endif // !VCSN_XML_HANDLERS_HXX
