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

# xml_converter.hxx

Go to the documentation of this file.

    00001 // xml_converter.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 #ifndef VCSN_XML_XML_CONVERTER_HXX
    00018 # define VCSN_XML_XML_CONVERTER_HXX
    00019
    00020 # include <vaucanson/xml/tools.hh>
    00021
    00034 namespace vcsn
    00035 {
    00036   namespace xml
    00037   {
    00038
    00039     template <class Auto>
    00040     xml_converter<Auto>::xml_converter (bool use_label_node)
    00041         : impl_(0), doc_(0), root_(0), use_label_node_(use_label_node)
    00042     {}
    00043
    00044     template <class Auto>
    00045     template <class OStream>
    00046     void xml_converter<Auto>::save(const Auto& aut, OStream& os,
    00047                                    const std::string& name)
    00048     {
    00049       create_document(aut, name);
    00050       tools::print_document(impl_, root_, os);
    00051     }
    00052
    00053     template <class Auto>
    00054     void xml_converter<Auto>::create_document(const Auto& aut,
    00055                                               const std::string& name)
    00056     {
    00057       typedef typename Auto::state_iterator state_iterator;
    00058       typedef typename Auto::transition_iterator transition_iterator;
    00059       typedef typename Auto::initial_iterator initial_iterator;
    00060       typedef typename Auto::final_iterator final_iterator;
    00061       using namespace xercesc;
    00062
    00063       // Document creation.
    00064       impl_ = DOMImplementationRegistry::getDOMImplementation(transcode("LS"));
    00065       doc_ = impl_->createDocument(transcode(VCSN_XMLNS),
    00066                                    transcode("automaton"), 0);
    00067       root_ = doc_->getDocumentElement();
    00068
    00069       tools::xset_attribute(root_, "name", aut.geometry().name());
    00070       tools::xset_attribute(root_, "name", name);
    00071
    00072       // Create type tag.
    00073       chooser_.create_type_tag(aut, doc_, root_);
    00074
    00075       DOMElement* content = tools::create_element(doc_, "content");
    00076       root_->appendChild(content);
    00077
    00078       // Create states.
    00079       DOMElement* node = tools::create_element(doc_, "states");
    00080       content->appendChild(node);
    00081       map_t state2str;
    00082       for_all_states(s, aut)
    00083         state2str[*s] = create_state(*s, aut, node);
    00084
    00085       // Create transitions.
    00086       node = tools::create_element(doc_, "transitions");
    00087       content->appendChild(node);
    00088       for_all_transitions(e, aut)
    00089         create_transition(*e, aut, node, state2str);
    00090
    00091       // Create initial transitions.
    00092       for_all_initial_states(i, aut)
    00093         create_initial(*i, aut, node, state2str);
    00094
    00095       // Create final transitions.
    00096       for_all_final_states(f, aut)
    00097         create_final(*f, aut, node, state2str);
    00098     }
    00099
    00100
    00101     template <class Auto>
    00102     xercesc::DOMElement*
    00103     xml_converter<Auto>::root_get()
    00104     {
    00105       return root_;
    00106     }
    00107
    00108     // Create a state in the XML document.
    00109     template <class Auto>
    00110     std::string
    00111     xml_converter<Auto>::create_state(hstate_t s,
    00112                                       const Auto& aut,
    00113                                       xercesc::DOMElement* root)
    00114     {
    00115       xercesc::DOMElement* node = tools::create_element(doc_, "state");
    00116       root->appendChild(node);
    00117       std::ostringstream os;
    00118       os << "s" << s;
    00119       tools::set_attribute(node, "name", os.str());
    00120       add_xml_geometry(aut.geometry().states(), s, node);
    00121
    00122       return os.str();
    00123     }
    00124
    00125
    00126     // Create a transition in the XML document.
    00127     template <class Auto>
    00128     void
    00129     xml_converter<Auto>::create_transition(htransition_t e,
    00130                                            const Auto& aut,
    00131                                            xercesc::DOMElement* root,
    00132                                            map_t& state2str)
    00133     {
    00134       xercesc::DOMElement* node = tools::create_element(doc_, "transition");
    00135       root->appendChild(node);
    00136       tools::set_attribute(node, "src", state2str[aut.src_of(e)]);
    00137       tools::set_attribute(node, "dst", state2str[aut.dst_of(e)]);
    00138       chooser_.create_label(doc_, e, aut, node, use_label_node_);
    00139       add_xml_drawing(aut.geometry().transitions(), e, node);
    00140     }
    00141
    00142
    00143     // Create an initial state in the XML document.
    00144     template <class Auto>
    00145     void
    00146     xml_converter<Auto>::create_initial(hstate_t s,
    00147                                         const Auto& aut,
    00148                                         xercesc::DOMElement* root,
    00149                                         map_t& state2str)
    00150     {
    00151       xercesc::DOMElement* node = tools::create_element(doc_, "initial");
    00152       root->appendChild(node);
    00153       tools::set_attribute(node, "state", state2str[s]);
    00154       chooser_.create_initial_label(doc_, s, aut, node, use_label_node_);
    00155       add_xml_drawing(aut.geometry().initials(), s, node);
    00156     }
    00157
    00158
    00159     // Create a final state in the XML document.
    00160     template <class Auto>
    00161     void
    00162     xml_converter<Auto>::create_final(hstate_t s,
    00163                                       const Auto& aut,
    00164                                       xercesc::DOMElement* root,
    00165                                       map_t& state2str)
    00166     {
    00167       xercesc::DOMElement* node = tools::create_element(doc_, "final");
    00168       root->appendChild(node);
    00169       tools::set_attribute(node, "state", state2str[s]);
    00170       chooser_.create_final_label(doc_, s, aut, node, use_label_node_);
    00171       add_xml_drawing(aut.geometry().finals(), s, node);
    00172     }
    00173
    00174
    00175     // Add geometry informations in the XML document.
    00176     template <class Auto>
    00177     template <class Map, class Key>
    00178     void
    00179     xml_converter<Auto>::add_xml_geometry(Map& map,
    00180                                           Key& key,
    00181                                           xercesc::DOMElement* root)
    00182     {
    00183       typename Map::const_iterator iter;
    00184       if ((iter = map.find(key)) != map.end())
    00185       {
    00186         std::ostringstream osx, osy;
    00187         osx << iter->second.first;
    00188         xercesc::DOMElement* nd = tools::create_element(doc_, "geometry");
    00189         root->appendChild(nd);
    00190         tools::set_attribute(nd, "x", osx.str());
    00191         osy << iter->second.second;
    00192         tools::set_attribute(nd, "y", osy.str());
    00193       }
    00194     }
    00195
    00196
    00197     // Add drawing informations in the XML document.
    00198     template <class Auto>
    00199     template <class Map, class Key>
    00200     void
    00201     xml_converter<Auto>::add_xml_drawing(Map& map,
    00202                                          Key& key,
    00203                                          xercesc::DOMElement* root)
    00204     {
    00205       typename Map::const_iterator iter;
    00206       if ((iter = map.find(key)) != map.end())
    00207       {
    00208         std::ostringstream osx, osy;
    00209         osx << iter->second.first;
    00210         xercesc::DOMElement* nd = tools::create_element(doc_, "drawing");
    00211         root->appendChild(nd);
    00212         tools::set_attribute(nd, "labelPositionX", osx.str());
    00213         osy << iter->second.second;
    00214         tools::set_attribute(nd, "labelPositionY", osy.str());
    00215       }
    00216     }
    00217
    00218
    00232     template <class Auto>
    00233     template <class IStream>
    00234     void
    00235     xml_converter<Auto>::load(Auto& aut, IStream& in)
    00236     {
    00237       root_ = xerces_parser::stream_parser(in);
    00238
    00239       typedef Node<Auto> node_t;
    00240       Factory<node_t, std::string> f;
    00241       register_all_factory(f, Auto);
    00242       typename node_t::map_t str2state;
    00243
    00244       node_t* node = factory_create(f, xml2str(root_->getNodeName()));
    00245       node->process(root_, aut, str2state, f);
    00246     }
    00247
    00248
    00249   } // !xml
    00250
    00251 } // !vcsn
    00252
    00253
    00254 #endif // ! VCSN_XML_XML_CONVERTER_HXX