Vaucanson  1.4.1
rw.hxx
1 // rw.hxx: this file is part of the Vaucanson project.
2 //
3 // Vaucanson, a generic library for finite state machines.
4 //
5 // Copyright (C) 2007, 2008, 2011 The Vaucanson Group.
6 //
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License
9 // as published by the Free Software Foundation; either version 2
10 // of the License, or (at your option) any later version.
11 //
12 // The complete GNU General Public Licence Notice can be found as the
13 // `COPYING' file in the root directory.
14 //
15 // The Vaucanson Group consists of people listed in the `AUTHORS' file.
16 //
17 
18 #ifndef VCSN_XML_CONTEXTS_RW_HXX
19 # define VCSN_XML_CONTEXTS_RW_HXX
20 
21 # include <vaucanson/xml/builders.hh>
22 
23 namespace vcsn
24 {
25  namespace xml
26  {
30  template <typename T>
31  SeriesSemiringHandler<T>::SeriesSemiringHandler (xercesc::SAX2XMLReader* parser,
32  Handler& root,
33  T& semiring)
34  : Handler(parser, root),
35  semiring_(semiring),
36  ssemiringh_(0),
37  monoidh_(0),
38  unsuph_(parser, *this)
39  {
40  }
41 
42  template <typename T>
43  void
44  SeriesSemiringHandler<T>::start (const XMLCh* const,
45  const XMLCh* const localname,
46  const XMLCh* const,
47  const xercesc::Attributes& attrs)
48  {
49  if (xercesc::XMLString::equals(eq_.semiring, localname))
50  {
51  ssemiringh_ = builders::create_semiringh(semiring_.semiring(), attrs, parser_, *this);
52  parser_->setContentHandler(ssemiringh_);
53  }
54  else if (xercesc::XMLString::equals(eq_.monoid, localname))
55  {
56  monoidh_ = builders::create_monoidh(const_cast <typename T::monoid_t&>(semiring_.monoid()), attrs, parser_, *this);
57  parser_->setContentHandler(monoidh_);
58  }
59  else
60  error::token(localname);
61  }
62 
63  template <typename T>
64  void
65  SeriesSemiringHandler<T>::end (const XMLCh* const,
66  const XMLCh* const localname,
67  const XMLCh* const)
68  {
69  if (xercesc::XMLString::equals(eq_.semiring, localname))
70  parser_->setContentHandler(&root_);
71  else
72  error::token(localname);
73  delete ssemiringh_;
74  delete monoidh_;
75  }
76 
77  namespace builders
78  {
79  template <typename S, typename K, typename T>
80  typename TRANStype::semiring_t*
81  create_semiring (TRANStype&,
82  const XMLCh* const,
83  const xercesc::Attributes&)
84  {
85  typename TRANStype::semiring_t::monoid_t::alphabet_t at;
86  typename TRANStype::semiring_t::monoid_t md(at);
87  typename TRANStype::semiring_t::semiring_t ssg;
88  typedef typename TRANStype::semiring_t semiring_t;
89  semiring_t* semiring = new semiring_t(ssg, md);
90 
91  return semiring;
92  }
93 
94  template <typename S, typename T>
95  Handler*
96  create_semiringh(TRANSsemiring& semiring,
97  const xercesc::Attributes&,
98  xercesc::SAX2XMLReader* parser,
99  Handler& root)
100  {
101  return new SeriesSemiringHandler<TRANSsemiring >(parser, root, semiring);
102  }
103 
104  } // !builders
105 
109  namespace builders
110  {
111  template <typename S, typename T>
112  const char* get_semiring_operations(const vcsn::algebra::Series<S, T>&)
113  {
114  return "SHOULD not append";
115  }
116  } // !builders
117 
118  namespace builders
119  {
120  template <typename S, typename K, typename T>
121  void
122  create_semiring_node(const TRANStype& aut,
123  xercesc::DOMDocument* doc,
124  xercesc::DOMElement* root)
125  {
126  xercesc::DOMElement* node = tools::create_element(doc, "semiring");
127  tools::set_attribute(node, "type", "series");
128  xercesc::DOMElement* semiringn = tools::create_element(doc, "semiring");
129  xercesc::DOMElement* monoid = tools::create_element(doc, "monoid");
130 
131  typedef typename TRANStype::semiring_elt_t::semiring_elt_t semiring_elt_t;
132  semiring_elt_t semiring;
133  tools::set_attribute(semiringn, "type", "numerical");
134  tools::set_attribute(semiringn, "set", get_semiring_set(semiring.value()));
135  tools::set_attribute(semiringn, "operations", get_semiring_operations(semiring.structure()));
136 
137  tools::set_attribute(monoid, "type", "free");
138  tools::set_attribute(monoid, "genDescrip", "enum");
139  tools::set_attribute(monoid, "genKind", algebra::letter_traits<typename TRANStype::semiring_t::monoid_t::alphabet_t::letter_t>::kind());
140  typedef typename TRANStype::semiring_t::monoid_t::alphabet_t::const_iterator alphabet_iterator;
141  for_all_letters(l, aut.series().semiring().monoid().alphabet())
142  {
143  std::ostringstream letter;
144  xercesc::DOMElement* gen = tools::create_element(doc, "monGen");
145  letter << *l;
146  tools::set_attribute(gen, "value", letter.str());
147  monoid->appendChild(gen);
148  }
149  tools::set_attribute(monoid, "genSort", get_monoid_gen_sort(*(aut.series().semiring().monoid().alphabet().begin())));
150  node->appendChild(semiringn);
151  node->appendChild(monoid);
152  root->appendChild(node);
153  }
154  }
155 
160  SParamTRANS
161  WeightHandler<TRANSseries >::WeightHandler (xercesc::SAX2XMLReader* parser,
162  Handler& root,
163  TRANSseries param)
164  : RegexpHandler<TRANSseries >(parser, root, param),
165  weighth_(0)
166  {
167  end_ = eq_.weight;
168  }
169 
170  SParamTRANS
171  void
172  WeightHandler<TRANSseries >::start (const XMLCh* const,
173  const XMLCh* const localname,
174  const XMLCh* const,
175  const xercesc::Attributes&)
176  {
177  //RegexpHandler<series_set_elt_t>* tmp = new RegexpHandler<series_set_elt_t>(parser_, *this,
178 // algebra::identity_as<typename series_set_elt_t::value_t>::of(param_.structure().semiring()));
179  if (!(weighth_ = create_weighth(localname)))
180  error::token(localname);
181  else
182  parser_->setContentHandler(weighth_);
183  }
184 
185  SParamTRANS
186  void
187  WeightHandler<TRANSseries >::end (const XMLCh* const,
188  const XMLCh* const localname,
189  const XMLCh* const)
190  {
191 
192  using namespace xercesc;
193  if (XMLString::equals(end_, localname))
194  {
195  TRANSseries s = algebra::identity_as<typename TRANSseries::value_t>::of(param_.structure());
196  typename TRANSseries::semiring_elt_t w(weighth_->series());
197  param_ = param_ * w;
198 
199  parser_->setContentHandler(&root_);
200  delete weighth_;
201  }
202  else
203  error::token(localname);
204  }
205 
206  SParamTRANS
207  RegexpHandler<typename WeightHandler<TRANSseries >::series_set_elt_t>*
208  WeightHandler<TRANSseries >::create_weighth (const XMLCh* const localname)
209  {
210  using namespace xercesc;
211  series_set_elt_t elt(param_.structure().semiring());
212 
213  if (XMLString::equals(eq_.monElmt, localname))
214  return builders::create_monElmth(parser_, *this, algebra::identity_as<typename series_set_elt_t::value_t>::of(elt.structure()));
215  else if (XMLString::equals(eq_.star, localname))
216  return new StarHandler<series_set_elt_t>(parser_, *this, algebra::identity_as<typename series_set_elt_t::value_t>::of(elt.structure()));
217  else if (XMLString::equals(eq_.leftExtMul, localname))
218  return new ExtMulHandler<series_set_elt_t>(parser_, *this, algebra::identity_as<typename series_set_elt_t::value_t>::of(elt.structure()), true);
219  else if (XMLString::equals(eq_.rightExtMul, localname))
220  return new ExtMulHandler<series_set_elt_t>(parser_, *this, algebra::identity_as<typename series_set_elt_t::value_t>::of(elt.structure()), false);
221  else if (XMLString::equals(eq_.sum, localname))
222  return new SumHandler<series_set_elt_t>(parser_, *this, algebra::identity_as<typename series_set_elt_t::value_t>::of(elt.structure()));
223  else if (XMLString::equals(eq_.product, localname))
224  return new ProductHandler<series_set_elt_t>(parser_, *this, algebra::identity_as<typename series_set_elt_t::value_t>::of(elt.structure()));
225  else if (XMLString::equals(eq_.one, localname))
226  return new AtomHandler<series_set_elt_t>(parser_, *this, algebra::identity_as<typename series_set_elt_t::value_t>::of(elt.structure()), eq_.one);
227  else if (XMLString::equals(eq_.zero, localname))
228  return new AtomHandler<series_set_elt_t>(parser_, *this, algebra::zero_as<typename series_set_elt_t::value_t>::of(elt.structure()), eq_.zero);
229  else
230  return 0;
231  }
232 
233  namespace builders
234  {
235  SParamTRANS
236  RegexpHandler<TRANSseries >*
237  create_weighth(xercesc::SAX2XMLReader* parser,
238  RegexpHandler<TRANSseries >& root,
239  TRANSseries param,
240  const xercesc::Attributes&)
241  {
242  return new WeightHandler<TRANSseries >(parser, root, param);
243  }
244  } // !builders
245  } // !xml
246 } // !vcsn
247 
248 #endif // !VCSN_XML_CONTEXTS_RW_HXX
Generated on Sat Jul 14 2012 18:46:40 for Vaucanson by   doxygen 1.8.1.1