Vaucanson: automata_base.hxx Source File

00001 // automata_base.hxx: this file is part of the Vaucanson project.
00002 //
00003 // Vaucanson, a generic library for finite state machines.
00004 //
00005 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008 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_AUTOMATA_CONCEPT_AUTOMATA_BASE_HXX
00018 # define VCSN_AUTOMATA_CONCEPT_AUTOMATA_BASE_HXX
00019 
00020 # include <vaucanson/automata/concept/copy.hh>
00021 # include <vaucanson/automata/concept/automata_base.hh>
00022 # include <vaucanson/automata/concept/automata_ops.hh>
00023 
00024 namespace vcsn {
00025 
00026   template <typename Self>
00027   AutomataBase<Self>::AutomataBase()
00028   {}
00029 
00030   template <typename Self>
00031   AutomataBase<Self>::AutomataBase(const AutomataBase& other) :
00032     Structure<Self>(other)
00033   {}
00034 
00035   template <typename Self>
00036   const typename AutomataBase<Self>::series_set_t&
00037   AutomataBase<Self>::series() const
00038   {
00039     return this->self().series();
00040   }
00041 
00042 
00044   template <typename Self, typename T>
00045   MetaElement<AutomataBase<Self>, T>::MetaElement()
00046   {}
00047 
00049   template <typename Self, typename T>
00050   MetaElement<AutomataBase<Self>, T>::MetaElement(const MetaElement& a):
00051     MetaElement<Structure<Self>, T>::MetaElement(a)
00052   {}
00053 
00055   template <typename Self, typename T>
00056   typename MetaElement<AutomataBase<Self>, T>::tag_t&
00057   MetaElement<AutomataBase<Self>, T>::tag()
00058   {
00059     return op_tag(this->structure(), this->value());
00060   }
00061 
00063   template <typename Self, typename T>
00064   const typename MetaElement<AutomataBase<Self>, T>::tag_t&
00065   MetaElement<AutomataBase<Self>, T>:: tag() const
00066   {
00067     return op_tag(this->structure(), this->value());
00068   }
00069 
00071   template <typename Self, typename T>
00072   typename MetaElement<AutomataBase<Self>, T>::geometry_t&
00073   MetaElement<AutomataBase<Self>, T>::geometry()
00074   {
00075     return op_geometry(this->structure(), this->value());
00076   }
00077 
00079   template <typename Self, typename T>
00080   const typename MetaElement<AutomataBase<Self>, T>::geometry_t&
00081   MetaElement<AutomataBase<Self>, T>::geometry() const
00082   {
00083     return op_geometry(this->structure(), this->value());
00084   }
00085 
00087   template <typename Self, typename T>
00088   bool
00089   MetaElement<AutomataBase<Self>, T>::exists() const
00090   {
00091     return op_exists(this->structure(), this->value());
00092   }
00093 
00095   template <typename Self, typename T>
00096   typename automaton_traits<T>::states_t
00097   MetaElement<AutomataBase<Self>, T>::states() const
00098   {
00099     return op_states(this->structure(), this->value());
00100   }
00101 
00103   template <typename Self, typename T>
00104   typename automaton_traits<T>::transitions_t
00105   MetaElement<AutomataBase<Self>, T>::transitions() const
00106   {
00107     return op_transitions(this->structure(), this->value());
00108   }
00109 
00111   template <typename Self, typename T>
00112   const typename MetaElement<AutomataBase<Self>, T>::series_set_t&
00113   MetaElement<AutomataBase<Self>, T>::series() const
00114   {
00115     return this->structure().series();
00116   }
00117 
00119   template <typename Self, typename T>
00120   typename automaton_traits<T>::initial_support_t
00121   MetaElement<AutomataBase<Self>, T>::initial() const
00122   {
00123     return op_initial(this->structure(), this->value());
00124   }
00125 
00127   template <typename Self, typename T>
00128   typename automaton_traits<T>::final_support_t
00129 
00130   MetaElement<AutomataBase<Self>, T>::final() const
00131   {
00132     return op_final(this->structure(), this->value());
00133   }
00134 
00137   template <typename Self, typename T>
00138   bool
00139   MetaElement<AutomataBase<Self>, T>::is_initial(const typename automaton_traits<T>::hstate_t& state) const
00140   {
00141     return op_is_initial(this->structure(), this->value(), state);
00142   }
00143 
00144   template <typename Self, typename T>
00145   bool
00146   MetaElement<AutomataBase<Self>, T>::is_initial(unsigned state) const
00147   {
00148     return op_is_initial(this->structure(), this->value(), state);
00149   }
00150 
00152   template <typename Self, typename T>
00153   bool
00154   MetaElement<AutomataBase<Self>, T>::is_final(const typename automaton_traits<T>::hstate_t& state) const
00155   {
00156     return op_is_final(this->structure(), this->value(), state);
00157   }
00158 
00159   template <typename Self, typename T>
00160   bool
00161   MetaElement<AutomataBase<Self>, T>::is_final(unsigned state) const
00162   {
00163     return op_is_final(this->structure(), this->value(), state);
00164   }
00165 
00167   template <typename Self, typename T>
00168   void
00169   MetaElement<AutomataBase<Self>, T>::set_initial(const typename automaton_traits<T>::hstate_t& state)
00170   {
00171     op_set_initial(this->structure(),
00172                    this->value(),
00173                    state,
00174                    this->structure().series().
00175                    identity(SELECT(series_set_elt_value_t)));
00176   }
00177 
00178   template <typename Self, typename T>
00179   void
00180   MetaElement<AutomataBase<Self>, T>::set_initial(unsigned state)
00181   {
00182     op_set_initial(this->structure(),
00183                    this->value(),
00184                    state,
00185                    this->structure().series().
00186                    identity(SELECT(series_set_elt_value_t)));
00187   }
00188 
00190   template <typename Self, typename T>
00191   void
00192   MetaElement<AutomataBase<Self>, T>::
00193   set_initial(const typename automaton_traits<T>::hstate_t& state, const series_set_elt_t& s)
00194   {
00195     op_set_initial(this->structure(), this->value(), state, s);
00196   }
00197 
00198   template <typename Self, typename T>
00199   void
00200   MetaElement<AutomataBase<Self>, T>::
00201   set_initial(unsigned state, const series_set_elt_t& s)
00202   {
00203     op_set_initial(this->structure(), this->value(), state, s);
00204   }
00205 
00207   template <typename Self, typename T>
00208   void
00209   MetaElement<AutomataBase<Self>, T>::set_final(const typename automaton_traits<T>::hstate_t& state)
00210   {
00211     op_set_final(this->structure(),
00212                  this->value(),
00213                  state,
00214                  this->structure().series().
00215                  identity(SELECT(series_set_elt_value_t)));
00216   }
00217 
00218   template <typename Self, typename T>
00219   void
00220   MetaElement<AutomataBase<Self>, T>::set_final(unsigned state)
00221   {
00222     op_set_final(this->structure(),
00223                  this->value(),
00224                  state,
00225                  this->structure().series().
00226                  identity(SELECT(series_set_elt_value_t)));
00227   }
00228 
00230   template <typename Self, typename T>
00231   void
00232   MetaElement<AutomataBase<Self>, T>::
00233   set_final(const typename automaton_traits<T>::hstate_t& state, const series_set_elt_t& s)
00234   {
00235     op_set_final(this->structure(), this->value(), state, s);
00236   }
00237 
00238   template <typename Self, typename T>
00239   void
00240   MetaElement<AutomataBase<Self>, T>::
00241   set_final(unsigned state, const series_set_elt_t& s)
00242   {
00243     op_set_final(this->structure(), this->value(), state, s);
00244   }
00245 
00247   template <typename Self, typename T>
00248   void
00249   MetaElement<AutomataBase<Self>, T>::unset_initial(const typename automaton_traits<T>::hstate_t& state)
00250   {
00251     op_set_initial(this->structure(),
00252                    this->value(),
00253                    state,
00254                    algebra::zero_as<series_set_elt_value_t>::
00255 		   of(this->structure().series()));
00256   }
00257 
00258   template <typename Self, typename T>
00259   void
00260   MetaElement<AutomataBase<Self>, T>::unset_initial(unsigned state)
00261   {
00262     op_set_initial(this->structure(),
00263                    this->value(),
00264                    state,
00265                    algebra::zero_as<series_set_elt_value_t>::
00266 		   of(this->structure().series()));
00267   }
00268 
00270   template <typename Self, typename T>
00271   void
00272   MetaElement<AutomataBase<Self>, T>::unset_final(const typename automaton_traits<T>::hstate_t& state)
00273   {
00274     op_set_final(this->structure(),
00275                  this->value(),
00276                  state,
00277                  algebra::zero_as<series_set_elt_value_t>::
00278 		 of(this->structure().series()));
00279   }
00280 
00281   template <typename Self, typename T>
00282   void
00283   MetaElement<AutomataBase<Self>, T>::unset_final(unsigned state)
00284   {
00285     op_set_final(this->structure(),
00286                  this->value(),
00287                  state,
00288                  algebra::zero_as<series_set_elt_value_t>::
00289 		 of(this->structure().series()));
00290   }
00291 
00293   template <typename Self, typename T>
00294   void
00295   MetaElement<AutomataBase<Self>, T>::clear_initial()
00296   {
00297     return op_clear_initial(this->structure(), this->value());
00298   }
00299 
00301   template <typename Self, typename T>
00302   void
00303   MetaElement<AutomataBase<Self>, T>::clear_final()
00304   {
00305     return op_clear_final(this->structure(), this->value());
00306   }
00307 
00309   template <typename Self, typename T>
00310   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_t
00311   MetaElement<AutomataBase<Self>, T>::get_initial(const typename automaton_traits<T>::hstate_t& state) const
00312   {
00313     return op_get_initial(this->structure(), this->value(), state);
00314   }
00315 
00316   template <typename Self, typename T>
00317   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_t
00318   MetaElement<AutomataBase<Self>, T>::get_initial(unsigned state) const
00319   {
00320     return op_get_initial(this->structure(), this->value(), state);
00321   }
00322 
00324   template <typename Self, typename T>
00325   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_t
00326   MetaElement<AutomataBase<Self>, T>::get_final(const typename automaton_traits<T>::hstate_t& state) const
00327   {
00328     return op_get_final(this->structure(), this->value(), state);
00329   }
00330 
00331   template <typename Self, typename T>
00332   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_t
00333   MetaElement<AutomataBase<Self>, T>::get_final(unsigned state) const
00334   {
00335     return op_get_final(this->structure(), this->value(), state);
00336   }
00337 
00339   template <typename Self, typename T>
00340   typename automaton_traits<T>::hstate_t
00341   MetaElement<AutomataBase<Self>, T>::add_state()
00342   {
00343     return op_add_state(this->structure(), this->value());
00344   }
00345 
00347   template <typename Self, typename T>
00348   typename automaton_traits<T>::hstate_t
00349   MetaElement<AutomataBase<Self>, T>::get_state(unsigned state) const
00350   {
00351     return op_get_state(this->structure(), this->value(), state);
00352   }
00353 
00356   template <typename Self, typename T>
00357   typename automaton_traits<T>::hstate_t
00358   MetaElement<AutomataBase<Self>, T>::choose_state() const
00359   {
00360     return op_choose_state(this->structure(), this->value());
00361   }
00362 
00364   template <typename Self, typename T>
00365   typename automaton_traits<T>::htransition_t
00366   MetaElement<AutomataBase<Self>, T>::add_transition(const typename automaton_traits<T>::hstate_t& src,
00367                                                      const typename automaton_traits<T>::hstate_t& dst,
00368                                                      const label_t& label)
00369   {
00370     return op_add_transition(this->structure(), this->value(),
00371                              src, dst, label);
00372   }
00373 
00374   template <typename Self, typename T>
00375   typename automaton_traits<T>::htransition_t
00376   MetaElement<AutomataBase<Self>, T>::add_transition(unsigned src,
00377                                                      unsigned dst,
00378                                                      const label_t& label)
00379   {
00380     return op_add_transition(this->structure(), this->value(),
00381                              src, dst, label);
00382   }
00383 
00385   template <typename Self, typename T>
00386   typename automaton_traits<T>::htransition_t
00387   MetaElement<AutomataBase<Self>, T>::
00388   add_weighted_transition(const typename automaton_traits<T>::hstate_t& src,
00389                           const typename automaton_traits<T>::hstate_t& dst,
00390                           const semiring_elt_t& w,
00391                           const monoid_elt_value_t& m)
00392   {
00393     return op_add_weighted_transition(this->structure(), this->value(),
00394                                       src, dst, w, m);
00395   }
00396 
00397   template <typename Self, typename T>
00398   typename automaton_traits<T>::htransition_t
00399   MetaElement<AutomataBase<Self>, T>::
00400   add_weighted_transition(unsigned src,
00401                           unsigned dst,
00402                           const semiring_elt_t& w,
00403                           const monoid_elt_value_t& m)
00404   {
00405     return op_add_weighted_transition(this->structure(), this->value(),
00406                                       src, dst, w, m);
00407   }
00408 
00412   template <typename Self, typename T>
00413   typename automaton_traits<T>::htransition_t
00414   MetaElement<AutomataBase<Self>, T>::add_series_transition(const typename automaton_traits<T>::hstate_t& src,
00415                                                             const typename automaton_traits<T>::hstate_t& dst,
00416                                                             const series_set_elt_t& e)
00417   {
00418     return op_add_series_transition(this->structure(), this->value(),
00419                                     src, dst, e);
00420   }
00421 
00422   template <typename Self, typename T>
00423   typename automaton_traits<T>::htransition_t
00424   MetaElement<AutomataBase<Self>, T>::add_series_transition(unsigned src,
00425                                                             unsigned dst,
00426                                                             const series_set_elt_t& e)
00427   {
00428     return op_add_series_transition(this->structure(), this->value(),
00429                                     src, dst, e);
00430   }
00431 
00433   template <typename Self, typename T>
00434   typename automaton_traits<T>::htransition_t
00435   MetaElement<AutomataBase<Self>, T>::add_spontaneous(const typename automaton_traits<T>::hstate_t& src,
00436                                                       const typename automaton_traits<T>::hstate_t& dst)
00437   {
00438     semiring_elt_t w(this->structure().series().semiring());
00439     w = algebra::identity_as<semiring_elt_value_t>
00440       ::of(this->structure().series().semiring());
00441     return op_add_spontaneous(this->structure(), this->value(), src, dst, w);
00442   }
00443 
00444   template <typename Self, typename T>
00445   typename automaton_traits<T>::htransition_t
00446   MetaElement<AutomataBase<Self>, T>::add_spontaneous(unsigned src,
00447                                                       unsigned dst)
00448   {
00449     semiring_elt_t w(this->structure().series().semiring());
00450     w = algebra::identity_as<semiring_elt_value_t>
00451       ::of(this->structure().series().semiring());
00452     return op_add_spontaneous(this->structure(), this->value(), src, dst, w);
00453   }
00454 
00455   template <typename Self, typename T>
00456   typename automaton_traits<T>::htransition_t
00457   MetaElement<AutomataBase<Self>, T>::add_spontaneous(const typename automaton_traits<T>::hstate_t& src,
00458                                                       const typename automaton_traits<T>::hstate_t& dst,
00459                                                       const semiring_elt_t& w)
00460   {
00461     return op_add_spontaneous(this->structure(), this->value(), src, dst, w);
00462   }
00463 
00464   template <typename Self, typename T>
00465   typename automaton_traits<T>::htransition_t
00466   MetaElement<AutomataBase<Self>, T>::add_spontaneous(unsigned src,
00467                                                       unsigned dst,
00468                                                       const semiring_elt_t& w)
00469   {
00470     return op_add_spontaneous(this->structure(), this->value(), src, dst, w);
00471   }
00472 
00474   template <typename Self, typename T>
00475   typename automaton_traits<T>::htransition_t
00476   MetaElement<AutomataBase<Self>, T>::add_letter_transition(const typename automaton_traits<T>::hstate_t& src,
00477                                                             const typename automaton_traits<T>::hstate_t& dst,
00478                                                             const letter_t& l)
00479   {
00480     return op_add_letter_transition(this->structure(), this->value(),
00481                                     src, dst, l);
00482   }
00483 
00484   template <typename Self, typename T>
00485   typename automaton_traits<T>::htransition_t
00486   MetaElement<AutomataBase<Self>, T>::add_letter_transition(unsigned src,
00487                                                             unsigned dst,
00488                                                             const letter_t& l)
00489   {
00490     return op_add_letter_transition(this->structure(), this->value(),
00491                                     src, dst, l);
00492   }
00493 
00496   template <typename Self, typename T>
00497   typename automaton_traits<T>::htransition_t
00498   MetaElement<AutomataBase<Self>, T>::add_letter_transition(const typename automaton_traits<T>::hstate_t& src,
00499                                                             const typename automaton_traits<T>::hstate_t& dst,
00500                                                             const std::string& l)
00501   {
00502     return op_add_letter_transition(this->structure(), this->value(),
00503                                     src, dst, algebra::letter_traits<letter_t>::
00504 				    literal_to_letter(l));
00505   }
00506 
00507   template <typename Self, typename T>
00508   typename automaton_traits<T>::htransition_t
00509   MetaElement<AutomataBase<Self>, T>::add_letter_transition(unsigned src,
00510                                                             unsigned dst,
00511                                                             const std::string& l)
00512   {
00513     return op_add_letter_transition(this->structure(), this->value(),
00514                                     src, dst, algebra::letter_traits<letter_t>::
00515 				    literal_to_letter(l));
00516   }
00517 
00519   template <typename Self, typename T>
00520   void
00521   MetaElement<AutomataBase<Self>, T>::update(const typename automaton_traits<T>::htransition_t& e, const label_t& l)
00522   {
00523     op_update(this->structure(), this->value(), e, l);
00524   }
00525 
00527   template <typename Self, typename T>
00528   void
00529   MetaElement<AutomataBase<Self>, T>::del_state(const typename automaton_traits<T>::hstate_t& s)
00530   {
00531     return op_del_state(this->structure(), this->value(), s);
00532   }
00533 
00534   template <typename Self, typename T>
00535   void
00536   MetaElement<AutomataBase<Self>, T>::del_state(unsigned state)
00537   {
00538     return op_del_state(this->structure(), this->value(), state);
00539   }
00540 
00542   template <typename Self, typename T>
00543   void
00544   MetaElement<AutomataBase<Self>, T>::del_transition(const typename automaton_traits<T>::htransition_t& e)
00545   {
00546     return op_del_transition(this->structure(), this->value(), e);
00547   }
00548 
00550   template <typename Self, typename T>
00551   bool
00552   MetaElement<AutomataBase<Self>, T>::has_state(const typename automaton_traits<T>::hstate_t& s) const
00553   {
00554     return op_has_state(this->structure(), this->value(), s);
00555   }
00556 
00557   template <typename Self, typename T>
00558   bool
00559   MetaElement<AutomataBase<Self>, T>::has_state(unsigned state) const
00560   {
00561     return op_has_state(this->structure(), this->value(), state);
00562   }
00563 
00565   template <typename Self, typename T>
00566   bool
00567   MetaElement<AutomataBase<Self>, T>::has_transition(const typename automaton_traits<T>::htransition_t& e) const
00568   {
00569     return op_has_transition(this->structure(), this->value(), e);
00570   }
00571 
00573   template <typename Self, typename T>
00574   typename automaton_traits<T>::hstate_t
00575   MetaElement<AutomataBase<Self>, T>::src_of(const typename automaton_traits<T>::htransition_t& e) const
00576   {
00577     return op_src_of(this->structure(), this->value(), e);
00578   }
00579 
00581   template <typename Self, typename T>
00582   typename automaton_traits<T>::hstate_t
00583   MetaElement<AutomataBase<Self>, T>::dst_of(const typename automaton_traits<T>::htransition_t& e) const
00584   {
00585     return op_dst_of(this->structure(), this->value(), e);
00586   }
00587 
00589   template <typename Self, typename T>
00590   typename automaton_traits<T>::label_t
00591   MetaElement<AutomataBase<Self>, T>::label_of(const typename automaton_traits<T>::htransition_t& e) const
00592   {
00593     return op_label_of(this->structure(), this->value(), e);
00594   }
00595 
00597   template <typename Self, typename T>
00598   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_t
00599   MetaElement<AutomataBase<Self>, T>::series_of(const typename automaton_traits<T>::htransition_t& e) const
00600   {
00601     return op_series_of(this->structure(), this->value(), e);
00602   }
00603 
00605   template <typename Self, typename T>
00606   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_value_t
00607   MetaElement<AutomataBase<Self>, T>::series_value_of(const typename automaton_traits<T>::htransition_t& e) const
00608   {
00609     return op_series_value_of(this->structure(), this->value(), e);
00610   }
00611 
00613   template <typename Self, typename T>
00614   bool
00615   MetaElement<AutomataBase<Self>, T>::is_spontaneous(const typename automaton_traits<T>::htransition_t& e) const
00616   {
00617     return op_is_spontaneous(this->structure(), this->value(), e);
00618   }
00619 
00621   template <typename Self, typename T>
00622   typename MetaElement<AutomataBase<Self>, T>::monoid_elt_t
00623   MetaElement<AutomataBase<Self>, T>::word_of(const typename automaton_traits<T>::htransition_t& e) const
00624   {
00625     return op_word_of(this->structure(), this->value(), e);
00626   }
00627 
00629   template <typename Self, typename T>
00630   typename MetaElement<AutomataBase<Self>, T>::semiring_elt_t
00631   MetaElement<AutomataBase<Self>, T>::weight_of(const typename automaton_traits<T>::htransition_t& e) const
00632   {
00633     return op_weight_of(this->structure(), this->value(), e);
00634   }
00635 
00637   template <typename Self, typename T>
00638   typename MetaElement<AutomataBase<Self>, T>::monoid_elt_value_t
00639   MetaElement<AutomataBase<Self>, T>::word_value_of(const typename automaton_traits<T>::htransition_t& e) const
00640   {
00641     return op_word_value_of(this->structure(), this->value(), e);
00642   }
00643 
00647   template <typename Self, typename T>
00648   typename MetaElement<AutomataBase<Self>, T>::letter_t
00649   MetaElement<AutomataBase<Self>, T>::letter_of(const typename automaton_traits<T>::htransition_t& e) const
00650   {
00651     return op_letter_of(this->structure(), this->value(), e);
00652   }
00653 
00654   /*---------.
00655   | Deltas.  |
00656   `---------*/
00657 
00658   template <typename Self, typename T>
00659   template <typename OutputIterator, typename Kind>
00660   void
00661   MetaElement<AutomataBase<Self>, T>::delta(OutputIterator res,
00662                                             const typename automaton_traits<T>::hstate_t& src,
00663                                             delta_kind::kind<Kind> k) const
00664   {
00665     op_delta(this->structure(), this->value(), res, src, k);
00666   }
00667 
00668   template <typename Self, typename T>
00669   template <typename OutputIterator, typename Kind>
00670   void
00671   MetaElement<AutomataBase<Self>, T>::delta(OutputIterator res,
00672                                             unsigned src,
00673                                             delta_kind::kind<Kind> k) const
00674   {
00675     op_delta(this->structure(), this->value(), res, src, k);
00676   }
00677 
00678   template <typename Self, typename T>
00679   template <typename OutputIterator, typename L, typename Kind>
00680   void
00681   MetaElement<AutomataBase<Self>, T>::delta(OutputIterator res,
00682                                             const typename automaton_traits<T>::hstate_t& src,
00683                                             const L& query,
00684                                             delta_kind::kind<Kind> k) const
00685   {
00686     op_delta(this->structure(), this->value(), res, src, query, k);
00687   }
00688 
00689   template <typename Self, typename T>
00690   template <typename OutputIterator, typename L, typename Kind>
00691   void
00692   MetaElement<AutomataBase<Self>, T>::delta(OutputIterator res,
00693                                             unsigned src,
00694                                             const L& query,
00695                                             delta_kind::kind<Kind> k) const
00696   {
00697     op_delta(this->structure(), this->value(), res, src, query, k);
00698   }
00699 
00700   template <typename Self, typename T>
00701   template <typename OutputIterator, typename L, typename Kind>
00702   void
00703   MetaElement<AutomataBase<Self>, T>::letter_delta(OutputIterator res,
00704                                                    const typename automaton_traits<T>::hstate_t& src,
00705                                                    const L& letter,
00706                                                    delta_kind::kind<Kind> k) const
00707   {
00708     op_letter_delta(this->structure(), this->value(), res, src, letter, k);
00709   }
00710 
00711   template <typename Self, typename T>
00712   template <typename OutputIterator, typename L, typename Kind>
00713   void
00714   MetaElement<AutomataBase<Self>, T>::letter_delta(OutputIterator res,
00715                                                    unsigned src,
00716                                                    const L& letter,
00717                                                    delta_kind::kind<Kind> k) const
00718   {
00719     op_letter_delta(this->structure(), this->value(), res, src, letter, k);
00720   }
00721 
00722   template <typename Self, typename T>
00723   template <typename OutputIterator, typename Kind>
00724   void
00725   MetaElement<AutomataBase<Self>, T>
00726   ::spontaneous_delta(OutputIterator res,
00727                       const typename automaton_traits<T>::hstate_t& src,
00728                       delta_kind::kind<Kind> k) const
00729   {
00730     return op_spontaneous_delta(this->structure(), this->value(), res, src, k);
00731   }
00732 
00733   template <typename Self, typename T>
00734   template <typename OutputIterator, typename Kind>
00735   void
00736   MetaElement<AutomataBase<Self>, T>
00737   ::spontaneous_delta(OutputIterator res,
00738                       unsigned src,
00739                       delta_kind::kind<Kind> k) const
00740   {
00741     return op_spontaneous_delta(this->structure(), this->value(), res, src, k);
00742   }
00743 
00744   /*----------.
00745   | Deltacs.  |
00746   `----------*/
00747 
00748   template <typename Self, typename T>
00749   template <typename Container, typename Kind>
00750   void
00751   MetaElement<AutomataBase<Self>, T>::deltac(Container& res, const typename automaton_traits<T>::hstate_t& src,
00752                                              delta_kind::kind<Kind> k) const
00753   {
00754     op_deltac(this->structure(), this->value(), res, src, k);
00755   }
00756 
00757   template <typename Self, typename T>
00758   template <typename Container, typename Kind>
00759   void
00760   MetaElement<AutomataBase<Self>, T>::deltac(Container& res, unsigned src,
00761                                              delta_kind::kind<Kind> k) const
00762   {
00763     op_deltac(this->structure(), this->value(), res, src, k);
00764   }
00765 
00766   template <typename Self, typename T>
00767   template <typename Container, typename L, typename Kind>
00768   void
00769   MetaElement<AutomataBase<Self>, T>::deltac(Container& res,
00770                                              const typename automaton_traits<T>::hstate_t& src,
00771                                              const L& query,
00772                                              delta_kind::kind<Kind> k) const
00773   {
00774     op_deltac(this->structure(), this->value(), res, src, query, k);
00775   }
00776 
00777   template <typename Self, typename T>
00778   template <typename Container, typename L, typename Kind>
00779   void
00780   MetaElement<AutomataBase<Self>, T>::deltac(Container& res,
00781                                              unsigned src,
00782                                              const L& query,
00783                                              delta_kind::kind<Kind> k) const
00784   {
00785     op_deltac(this->structure(), this->value(), res, src, query, k);
00786   }
00787 
00788   template <typename Self, typename T>
00789   template <typename Container, typename L, typename Kind>
00790   void
00791   MetaElement<AutomataBase<Self>, T>::letter_deltac(Container& res,
00792                                                     const typename automaton_traits<T>::hstate_t& src,
00793                                                     const L& letter,
00794                                                     delta_kind::kind<Kind> k) const
00795   {
00796     op_letter_deltac(this->structure(), this->value(), res, src, letter, k);
00797   }
00798 
00799   template <typename Self, typename T>
00800   template <typename Container, typename L, typename Kind>
00801   void
00802   MetaElement<AutomataBase<Self>, T>::letter_deltac(Container& res,
00803                                                     unsigned src,
00804                                                     const L& letter,
00805                                                     delta_kind::kind<Kind> k) const
00806   {
00807     op_letter_deltac(this->structure(), this->value(), res, src, letter, k);
00808   }
00809 
00810   template <typename Self, typename T>
00811   template <typename Container, typename Kind>
00812   void
00813   MetaElement<AutomataBase<Self>, T>
00814   ::spontaneous_deltac(Container& res,
00815                        const typename automaton_traits<T>::hstate_t& src,
00816                        delta_kind::kind<Kind> k) const
00817   {
00818     op_spontaneous_deltac(this->structure(), this->value(), res, src, k);
00819   }
00820 
00821   template <typename Self, typename T>
00822   template <typename Container, typename Kind>
00823   void
00824   MetaElement<AutomataBase<Self>, T>
00825   ::spontaneous_deltac(Container& res,
00826                        unsigned src,
00827                        delta_kind::kind<Kind> k) const
00828   {
00829     op_spontaneous_deltac(this->structure(), this->value(), res, src, k);
00830   }
00831 
00832   /*----------.
00833   | Deltafs.  |
00834   `----------*/
00835 
00836   template <typename Self, typename T>
00837   template <typename Functor, typename Kind>
00838   void
00839   MetaElement<AutomataBase<Self>, T>::deltaf(Functor& fun, const typename automaton_traits<T>::hstate_t& src,
00840                                              delta_kind::kind<Kind> k) const
00841   {
00842     op_deltaf(this->structure(), this->value(), fun, src, k);
00843   }
00844 
00845   template <typename Self, typename T>
00846   template <typename Functor, typename Kind>
00847   void
00848   MetaElement<AutomataBase<Self>, T>::deltaf(Functor& fun, unsigned src,
00849                                              delta_kind::kind<Kind> k) const
00850   {
00851     op_deltaf(this->structure(), this->value(), fun, src, k);
00852   }
00853 
00854   template <typename Self, typename T>
00855   template <typename Functor, typename L, typename Kind>
00856   void
00857   MetaElement<AutomataBase<Self>, T>::deltaf(Functor& fun,
00858                                              const typename automaton_traits<T>::hstate_t& src,
00859                                              const L& query,
00860                                              delta_kind::kind<Kind> k) const
00861   {
00862     op_deltaf(this->structure(), this->value(), fun, src, query, k);
00863   }
00864 
00865   template <typename Self, typename T>
00866   template <typename Functor, typename L, typename Kind>
00867   void
00868   MetaElement<AutomataBase<Self>, T>::deltaf(Functor& fun,
00869                                              unsigned src,
00870                                              const L& query,
00871                                              delta_kind::kind<Kind> k) const
00872   {
00873     op_deltaf(this->structure(), this->value(), fun, src, query, k);
00874   }
00875 
00876   template <typename Self, typename T>
00877   template <typename Functor, typename L, typename Kind>
00878   void
00879   MetaElement<AutomataBase<Self>, T>::letter_deltaf(Functor& fun,
00880                                                     const typename automaton_traits<T>::hstate_t& src,
00881                                                     const L& letter,
00882                                                     delta_kind::kind<Kind> k) const
00883   {
00884     op_letter_deltaf(this->structure(), this->value(), fun, src, letter, k);
00885   }
00886 
00887   template <typename Self, typename T>
00888   template <typename Functor, typename L, typename Kind>
00889   void
00890   MetaElement<AutomataBase<Self>, T>::letter_deltaf(Functor& fun,
00891                                                     unsigned src,
00892                                                     const L& letter,
00893                                                     delta_kind::kind<Kind> k) const
00894   {
00895     op_letter_deltaf(this->structure(), this->value(), fun, src, letter, k);
00896   }
00897 
00898   template <typename Self, typename T>
00899   template <typename Functor, typename Kind>
00900   void
00901   MetaElement<AutomataBase<Self>, T>
00902   ::spontaneous_deltaf(Functor& fun,
00903                        const typename automaton_traits<T>::hstate_t& src,
00904                        delta_kind::kind<Kind> k) const
00905   {
00906     op_spontaneous_deltaf(this->structure(), this->value(), fun, src, k);
00907   }
00908 
00909   template <typename Self, typename T>
00910   template <typename Functor, typename Kind>
00911   void
00912   MetaElement<AutomataBase<Self>, T>
00913   ::spontaneous_deltaf(Functor& fun,
00914                        unsigned src,
00915                        delta_kind::kind<Kind> k) const
00916   {
00917     op_spontaneous_deltaf(this->structure(), this->value(), fun, src, k);
00918   }
00919 
00920   /*-----------------.
00921   | Reverse deltas.  |
00922   `-----------------*/
00923 
00924   template <typename Self, typename T>
00925   template <typename OutputIterator, typename Kind>
00926   void
00927   MetaElement<AutomataBase<Self>, T>::rdelta(OutputIterator res,
00928                                              const typename automaton_traits<T>::hstate_t& src,
00929                                              delta_kind::kind<Kind> k) const
00930   {
00931     op_rdelta(this->structure(), this->value(), res, src, k);
00932   }
00933 
00934   template <typename Self, typename T>
00935   template <typename OutputIterator, typename Kind>
00936   void
00937   MetaElement<AutomataBase<Self>, T>::rdelta(OutputIterator res,
00938                                              unsigned src,
00939                                              delta_kind::kind<Kind> k) const
00940   {
00941     op_rdelta(this->structure(), this->value(), res, src, k);
00942   }
00943 
00944   template <typename Self, typename T>
00945   template <typename OutputIterator, typename L, typename Kind>
00946   void
00947   MetaElement<AutomataBase<Self>, T>::rdelta(OutputIterator res,
00948                                              const typename automaton_traits<T>::hstate_t& src,
00949                                              const L& query,
00950                                              delta_kind::kind<Kind> k) const
00951   {
00952     op_rdelta(this->structure(), this->value(), res, src, query, k);
00953   }
00954 
00955   template <typename Self, typename T>
00956   template <typename OutputIterator, typename L, typename Kind>
00957   void
00958   MetaElement<AutomataBase<Self>, T>::rdelta(OutputIterator res,
00959                                              unsigned src,
00960                                              const L& query,
00961                                              delta_kind::kind<Kind> k) const
00962   {
00963     op_rdelta(this->structure(), this->value(), res, src, query, k);
00964   }
00965 
00966   template <typename Self, typename T>
00967   template <typename OutputIterator, typename L, typename Kind>
00968   void
00969   MetaElement<AutomataBase<Self>, T>::letter_rdelta(OutputIterator res,
00970                                                     const typename automaton_traits<T>::hstate_t& src,
00971                                                     const L& letter,
00972                                                     delta_kind::kind<Kind> k) const
00973   {
00974     op_letter_rdelta(this->structure(), this->value(), res, src, letter, k);
00975   }
00976 
00977   template <typename Self, typename T>
00978   template <typename OutputIterator, typename L, typename Kind>
00979   void
00980   MetaElement<AutomataBase<Self>, T>::letter_rdelta(OutputIterator res,
00981                                                     unsigned src,
00982                                                     const L& letter,
00983                                                     delta_kind::kind<Kind> k) const
00984   {
00985     op_letter_rdelta(this->structure(), this->value(), res, src, letter, k);
00986   }
00987 
00988   template <typename Self, typename T>
00989   template <typename OutputIterator, typename Kind>
00990   void
00991   MetaElement<AutomataBase<Self>, T>
00992   ::spontaneous_rdelta(OutputIterator res,
00993                        const typename automaton_traits<T>::hstate_t& src,
00994                        delta_kind::kind<Kind> k) const
00995   {
00996     return op_spontaneous_rdelta(this->structure(), this->value(), res, src, k);
00997   }
00998 
00999   template <typename Self, typename T>
01000   template <typename OutputIterator, typename Kind>
01001   void
01002   MetaElement<AutomataBase<Self>, T>
01003   ::spontaneous_rdelta(OutputIterator res,
01004                        unsigned src,
01005                        delta_kind::kind<Kind> k) const
01006   {
01007     return op_spontaneous_rdelta(this->structure(), this->value(), res, src, k);
01008   }
01009 
01010   /*------------------.
01011   | Reverse deltacs.  |
01012   `------------------*/
01013 
01014   template <typename Self, typename T>
01015   template <typename Container, typename Kind>
01016   void
01017   MetaElement<AutomataBase<Self>, T>::rdeltac(Container& res, const typename automaton_traits<T>::hstate_t& src,
01018                                               delta_kind::kind<Kind> k) const
01019   {
01020     op_rdeltac(this->structure(), this->value(), res, src, k);
01021   }
01022 
01023   template <typename Self, typename T>
01024   template <typename Container, typename Kind>
01025   void
01026   MetaElement<AutomataBase<Self>, T>::rdeltac(Container& res, unsigned src,
01027                                               delta_kind::kind<Kind> k) const
01028   {
01029     op_rdeltac(this->structure(), this->value(), res, src, k);
01030   }
01031 
01032   template <typename Self, typename T>
01033   template <typename Container, typename L, typename Kind>
01034   void
01035   MetaElement<AutomataBase<Self>, T>::rdeltac(Container& res,
01036                                               const typename automaton_traits<T>::hstate_t& src,
01037                                               const L& query,
01038                                               delta_kind::kind<Kind> k) const
01039   {
01040     op_rdeltac(this->structure(), this->value(), res, src, query, k);
01041   }
01042 
01043   template <typename Self, typename T>
01044   template <typename Container, typename L, typename Kind>
01045   void
01046   MetaElement<AutomataBase<Self>, T>::rdeltac(Container& res,
01047                                               unsigned src,
01048                                               const L& query,
01049                                               delta_kind::kind<Kind> k) const
01050   {
01051     op_rdeltac(this->structure(), this->value(), res, src, query, k);
01052   }
01053 
01054   template <typename Self, typename T>
01055   template <typename Container, typename L, typename Kind>
01056   void
01057   MetaElement<AutomataBase<Self>, T>::letter_rdeltac(Container& res,
01058                                                      const typename automaton_traits<T>::hstate_t& src,
01059                                                      const L& letter,
01060                                                      delta_kind::kind<Kind> k) const
01061   {
01062     op_letter_rdeltac(this->structure(), this->value(), res, src, letter, k);
01063   }
01064 
01065   template <typename Self, typename T>
01066   template <typename Container, typename L, typename Kind>
01067   void
01068   MetaElement<AutomataBase<Self>, T>::letter_rdeltac(Container& res,
01069                                                      unsigned src,
01070                                                      const L& letter,
01071                                                      delta_kind::kind<Kind> k) const
01072   {
01073     op_letter_rdeltac(this->structure(), this->value(), res, src, letter, k);
01074   }
01075 
01076   template <typename Self, typename T>
01077   template <typename Container, typename Kind>
01078   void
01079   MetaElement<AutomataBase<Self>, T>
01080   ::spontaneous_rdeltac(Container& res,
01081                         const typename automaton_traits<T>::hstate_t& src,
01082                         delta_kind::kind<Kind> k) const
01083   {
01084     op_spontaneous_rdeltac(this->structure(), this->value(), res, src, k);
01085   }
01086 
01087   template <typename Self, typename T>
01088   template <typename Container, typename Kind>
01089   void
01090   MetaElement<AutomataBase<Self>, T>
01091   ::spontaneous_rdeltac(Container& res,
01092                         unsigned src,
01093                         delta_kind::kind<Kind> k) const
01094   {
01095     op_spontaneous_rdeltac(this->structure(), this->value(), res, src, k);
01096   }
01097 
01098   /*------------------.
01099   | Reverse deltafs.  |
01100   `------------------*/
01101 
01102   template <typename Self, typename T>
01103   template <typename Functor, typename Kind>
01104   void
01105   MetaElement<AutomataBase<Self>, T>::rdeltaf(Functor& fun, const typename automaton_traits<T>::hstate_t& src,
01106                                               delta_kind::kind<Kind> k) const
01107   {
01108     op_rdeltaf(this->structure(), this->value(), fun, src, k);
01109   }
01110 
01111   template <typename Self, typename T>
01112   template <typename Functor, typename Kind>
01113   void
01114   MetaElement<AutomataBase<Self>, T>::rdeltaf(Functor& fun, unsigned src,
01115                                               delta_kind::kind<Kind> k) const
01116   {
01117     op_rdeltaf(this->structure(), this->value(), fun, src, k);
01118   }
01119 
01120   template <typename Self, typename T>
01121   template <typename Functor, typename L, typename Kind>
01122   void
01123   MetaElement<AutomataBase<Self>, T>::rdeltaf(Functor& fun,
01124                                               const typename automaton_traits<T>::hstate_t& src,
01125                                               const L& query,
01126                                               delta_kind::kind<Kind> k) const
01127   {
01128     op_rdeltaf(this->structure(), this->value(), fun, src, query, k);
01129   }
01130 
01131   template <typename Self, typename T>
01132   template <typename Functor, typename L, typename Kind>
01133   void
01134   MetaElement<AutomataBase<Self>, T>::rdeltaf(Functor& fun,
01135                                               unsigned src,
01136                                               const L& query,
01137                                               delta_kind::kind<Kind> k) const
01138   {
01139     op_rdeltaf(this->structure(), this->value(), fun, src, query, k);
01140   }
01141 
01142   template <typename Self, typename T>
01143   template <typename Functor, typename L, typename Kind>
01144   void
01145   MetaElement<AutomataBase<Self>, T>::letter_rdeltaf(Functor& fun,
01146                                                      const typename automaton_traits<T>::hstate_t& src,
01147                                                      const L& letter,
01148                                                      delta_kind::kind<Kind> k) const
01149   {
01150     op_letter_rdeltaf(this->structure(), this->value(), fun, src, letter, k);
01151   }
01152 
01153   template <typename Self, typename T>
01154   template <typename Functor, typename L, typename Kind>
01155   void
01156   MetaElement<AutomataBase<Self>, T>::letter_rdeltaf(Functor& fun,
01157                                                      unsigned src,
01158                                                      const L& letter,
01159                                                      delta_kind::kind<Kind> k) const
01160   {
01161     op_letter_rdeltaf(this->structure(), this->value(), fun, src, letter, k);
01162   }
01163 
01164   template <typename Self, typename T>
01165   template <typename Functor, typename Kind>
01166   void
01167   MetaElement<AutomataBase<Self>, T>
01168   ::spontaneous_rdeltaf(Functor& fun,
01169                         const typename automaton_traits<T>::hstate_t& src,
01170                         delta_kind::kind<Kind> k) const
01171   {
01172     op_spontaneous_rdeltaf(this->structure(), this->value(), fun, src, k);
01173   }
01174 
01175   template <typename Self, typename T>
01176   template <typename Functor, typename Kind>
01177   void
01178   MetaElement<AutomataBase<Self>, T>
01179   ::spontaneous_rdeltaf(Functor& fun,
01180                         unsigned src,
01181                         delta_kind::kind<Kind> k) const
01182   {
01183     op_spontaneous_rdeltaf(this->structure(), this->value(), fun, src, k);
01184   }
01185 
01186 
01187   template<typename S, typename St, typename T>
01188   St& op_rout(const AutomataBase<S>& s, St& st, const T& v)
01189   {
01190     Element<S, T> r(s.self(), v);
01191     st << "{ "
01192        << r.states().size() << " states, "
01193        << r.transitions().size() << " transitions, "
01194        << "#I = " << r.initial().size() << ", "
01195        << "#T = " << r.final().size()
01196        << " }";
01197     return st;
01198   }
01199 
01200   /*----------------------------------------------.
01201   | automaton to generalized automaton convertion |
01202   `----------------------------------------------*/
01203 
01204   template <typename Auto_>
01205   typename generalized_traits<Auto_>::automaton_t
01206   generalized(const Auto_& from)
01207   {
01208     typename generalized_traits<Auto_>::automaton_t to(from.structure());
01209     auto_copy(to, from);
01210     return to;
01211   }
01212 
01213 } // ! vcsn
01214 
01215 #endif // ! VCSN_AUTOMATA_CONCEPT_AUTOMATA_BASE_HXX