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

- File List
- File Members

# automata_base.hxx

    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).second);
    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).second);
    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   template<typename S, typename St, typename T>
    00655   St& op_rout(const AutomataBase<S>& s, St& st, const T& v)
    00656   {
    00657     Element<S, T> r(s.self(), v);
    00658     st << "{ "
    00659        << r.states().size() << " states, "
    00660        << r.transitions().size() << " transitions, "
    00661        << "#I = " << r.initial().size() << ", "
    00662        << "#T = " << r.final().size()
    00663        << " }";
    00664     return st;
    00665   }
    00666
    00667   /*----------------------------------------------.
    00668   | automaton to generalized automaton convertion |
    00669   `----------------------------------------------*/
    00670
    00671   template <typename Auto_>
    00672   typename generalized_traits<Auto_>::automaton_t
    00673   generalized(const Auto_& from)
    00674   {
    00675     typename generalized_traits<Auto_>::automaton_t to(from.structure());
    00676     auto_copy(to, from);
    00677     return to;
    00678   }
    00679
    00680 } // ! vcsn
    00681
    00682 #endif // ! VCSN_AUTOMATA_CONCEPT_AUTOMATA_BASE_HXX