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