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(hstate_t state) const
00139   {
00140     return (op_get_initial(this->structure(), this->value(), state) !=
00141             this->structure().series().zero(SELECT(series_set_elt_value_t)));
00142   }
00143 
00145   template <typename Self, typename T>
00146   bool
00147   MetaElement<AutomataBase<Self>, T>::is_final(hstate_t state) const
00148   {
00149     return
00150       op_get_final(this->structure(), this->value(), state) !=
00151       algebra::zero_as<series_set_elt_value_t>::
00152       of(this->structure().series());
00153   }
00154 
00156   template <typename Self, typename T>
00157   void
00158   MetaElement<AutomataBase<Self>, T>::set_initial(hstate_t state)
00159   {
00160     op_set_initial(this->structure(),
00161                    this->value(),
00162                    state,
00163                    this->structure().series().
00164                    identity(SELECT(series_set_elt_value_t)));
00165   }
00166 
00168   template <typename Self, typename T>
00169   void
00170   MetaElement<AutomataBase<Self>, T>::
00171   set_initial(hstate_t state, const series_set_elt_t& s)
00172   {
00173     op_set_initial(this->structure(), this->value(), state, s);
00174   }
00175 
00177   template <typename Self, typename T>
00178   void
00179   MetaElement<AutomataBase<Self>, T>::set_final(hstate_t state)
00180   {
00181     op_set_final(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_final(hstate_t state, const series_set_elt_t& s)
00193   {
00194     op_set_final(this->structure(), this->value(), state, s);
00195   }
00196 
00198   template <typename Self, typename T>
00199   void
00200   MetaElement<AutomataBase<Self>, T>::unset_initial(hstate_t state)
00201   {
00202     op_set_initial(this->structure(),
00203                    this->value(),
00204                    state,
00205                    algebra::zero_as<series_set_elt_value_t>::
00206 		   of(this->structure().series()));
00207   }
00208 
00210   template <typename Self, typename T>
00211   void
00212   MetaElement<AutomataBase<Self>, T>::unset_final(hstate_t state)
00213   {
00214     op_set_final(this->structure(),
00215                  this->value(),
00216                  state,
00217                  algebra::zero_as<series_set_elt_value_t>::
00218 		 of(this->structure().series()));
00219   }
00220 
00222   template <typename Self, typename T>
00223   void
00224   MetaElement<AutomataBase<Self>, T>::clear_initial()
00225   {
00226     return op_clear_initial(this->structure(), this->value());
00227   }
00228 
00230   template <typename Self, typename T>
00231   void
00232   MetaElement<AutomataBase<Self>, T>::clear_final()
00233   {
00234     return op_clear_final(this->structure(), this->value());
00235   }
00236 
00238   template <typename Self, typename T>
00239   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_t
00240   MetaElement<AutomataBase<Self>, T>::get_initial(hstate_t state) const
00241   {
00242     return op_get_initial(this->structure(), this->value(), state);
00243   }
00244 
00246   template <typename Self, typename T>
00247   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_t
00248   MetaElement<AutomataBase<Self>, T>::get_final(hstate_t what) const
00249   {
00250     return op_get_final(this->structure(), this->value(), what);
00251   }
00252 
00254   template <typename Self, typename T>
00255   hstate_t
00256   MetaElement<AutomataBase<Self>, T>::add_state()
00257   {
00258     return op_add_state(this->structure(), this->value());
00259   }
00260 
00263   template <typename Self, typename T>
00264   hstate_t
00265   MetaElement<AutomataBase<Self>, T>::choose_state() const
00266   {
00267     return op_choose_state(this->structure(), this->value());
00268   }
00269 
00271   template <typename Self, typename T>
00272   htransition_t
00273   MetaElement<AutomataBase<Self>, T>::add_transition(hstate_t src,
00274                                                      hstate_t dst,
00275                                                      const label_t& label)
00276   {
00277     return op_add_transition(this->structure(), this->value(),
00278                              src, dst, label);
00279   }
00280 
00282   template <typename Self, typename T>
00283   htransition_t
00284   MetaElement<AutomataBase<Self>, T>::
00285   add_weighted_transition(hstate_t src,
00286                           hstate_t dst,
00287                           const semiring_elt_t& w,
00288                           const monoid_elt_value_t& m)
00289   {
00290     return op_add_weighted_transition(this->structure(), this->value(),
00291                                       src, dst, w, m);
00292   }
00293 
00297   template <typename Self, typename T>
00298   htransition_t
00299   MetaElement<AutomataBase<Self>, T>::add_series_transition(hstate_t src,
00300                                                             hstate_t dst,
00301                                                             const series_set_elt_t& e)
00302   {
00303     return op_add_series_transition(this->structure(), this->value(),
00304                                     src, dst, e);
00305   }
00306 
00308   template <typename Self, typename T>
00309   htransition_t
00310   MetaElement<AutomataBase<Self>, T>::add_spontaneous(hstate_t src,
00311                                                       hstate_t dst)
00312   {
00313     semiring_elt_t w(this->structure().series().semiring());
00314     w = algebra::identity_as<semiring_elt_value_t>
00315       ::of(this->structure().series().semiring());
00316     return op_add_spontaneous(this->structure(), this->value(), src, dst, w);
00317   }
00318 
00319   template <typename Self, typename T>
00320   htransition_t
00321   MetaElement<AutomataBase<Self>, T>::add_spontaneous(hstate_t src,
00322                                                       hstate_t dst,
00323                                                       const semiring_elt_t& w)
00324   {
00325     return op_add_spontaneous(this->structure(), this->value(), src, dst, w);
00326   }
00327 
00329   template <typename Self, typename T>
00330   htransition_t
00331   MetaElement<AutomataBase<Self>, T>::add_letter_transition(hstate_t src,
00332                                                             hstate_t dst,
00333                                                             const letter_t& l)
00334   {
00335     return op_add_letter_transition(this->structure(), this->value(),
00336                                     src, dst, l);
00337   }
00338 
00340   template <typename Self, typename T>
00341   void
00342   MetaElement<AutomataBase<Self>, T>::update(htransition_t e, const label_t& l)
00343   {
00344     op_update(this->structure(), this->value(), e, l);
00345   }
00346 
00348   template <typename Self, typename T>
00349   void
00350   MetaElement<AutomataBase<Self>, T>::del_state(hstate_t s)
00351   {
00352     return op_del_state(this->structure(), this->value(), s);
00353   }
00354 
00356   template <typename Self, typename T>
00357   void
00358   MetaElement<AutomataBase<Self>, T>::del_transition(htransition_t e)
00359   {
00360     return op_del_transition(this->structure(), this->value(), e);
00361   }
00362 
00364   template <typename Self, typename T>
00365   bool
00366   MetaElement<AutomataBase<Self>, T>::has_state(hstate_t s) const
00367   {
00368     return op_has_state(this->structure(), this->value(), s);
00369   }
00370 
00372   template <typename Self, typename T>
00373   bool
00374   MetaElement<AutomataBase<Self>, T>::has_transition(htransition_t e) const
00375   {
00376     return op_has_transition(this->structure(), this->value(), e);
00377   }
00378 
00380   template <typename Self, typename T>
00381   hstate_t
00382   MetaElement<AutomataBase<Self>, T>::src_of(htransition_t e) const
00383   {
00384     return op_src_of(this->structure(), this->value(), e);
00385   }
00386 
00388   template <typename Self, typename T>
00389   hstate_t
00390   MetaElement<AutomataBase<Self>, T>::dst_of(htransition_t e) const
00391   {
00392     return op_dst_of(this->structure(), this->value(), e);
00393   }
00394 
00396   template <typename Self, typename T>
00397   typename automaton_traits<T>::label_t
00398   MetaElement<AutomataBase<Self>, T>::label_of(htransition_t e) const
00399   {
00400     return op_label_of(this->structure(), this->value(), e);
00401   }
00402 
00404   template <typename Self, typename T>
00405   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_t
00406   MetaElement<AutomataBase<Self>, T>::series_of(htransition_t e) const
00407   {
00408     return op_series_of(this->structure(), this->value(), e);
00409   }
00410 
00412   template <typename Self, typename T>
00413   typename MetaElement<AutomataBase<Self>, T>::series_set_elt_value_t
00414   MetaElement<AutomataBase<Self>, T>::series_value_of(htransition_t e) const
00415   {
00416     return op_series_value_of(this->structure(), this->value(), e);
00417   }
00418 
00420   template <typename Self, typename T>
00421   bool
00422   MetaElement<AutomataBase<Self>, T>::is_spontaneous(htransition_t e) const
00423   {
00424     return op_is_spontaneous(this->structure(), this->value(), e);
00425   }
00426 
00428   template <typename Self, typename T>
00429   typename MetaElement<AutomataBase<Self>, T>::monoid_elt_t
00430   MetaElement<AutomataBase<Self>, T>::word_of(htransition_t e) const
00431   {
00432     return op_word_of(this->structure(), this->value(), e);
00433   }
00434 
00436   template <typename Self, typename T>
00437   typename MetaElement<AutomataBase<Self>, T>::semiring_elt_t
00438   MetaElement<AutomataBase<Self>, T>::weight_of(htransition_t e) const
00439   {
00440     return op_weight_of(this->structure(), this->value(), e);
00441   }
00442 
00444   template <typename Self, typename T>
00445   typename MetaElement<AutomataBase<Self>, T>::monoid_elt_value_t
00446   MetaElement<AutomataBase<Self>, T>::word_value_of(htransition_t e) const
00447   {
00448     return op_word_value_of(this->structure(), this->value(), e);
00449   }
00450 
00454   template <typename Self, typename T>
00455   typename MetaElement<AutomataBase<Self>, T>::letter_t
00456   MetaElement<AutomataBase<Self>, T>::letter_of(htransition_t e) const
00457   {
00458     return op_letter_of(this->structure(), this->value(), e);
00459   }
00460 
00461   /*---------.
00462   | Deltas.  |
00463   `---------*/
00464 
00465   template <typename Self, typename T>
00466   template <typename OutputIterator, typename Kind>
00467   void
00468   MetaElement<AutomataBase<Self>, T>::delta(OutputIterator res,
00469                                             hstate_t src,
00470                                             delta_kind::kind<Kind> k) const
00471   {
00472     op_delta(this->structure(), this->value(), res, src, k);
00473   }
00474 
00475   template <typename Self, typename T>
00476   template <typename OutputIterator, typename L, typename Kind>
00477   void
00478   MetaElement<AutomataBase<Self>, T>::delta(OutputIterator res,
00479                                             hstate_t src,
00480                                             const L& query,
00481                                             delta_kind::kind<Kind> k) const
00482   {
00483     op_delta(this->structure(), this->value(), res, src, query, k);
00484   }
00485 
00486   template <typename Self, typename T>
00487   template <typename OutputIterator, typename L, typename Kind>
00488   void
00489   MetaElement<AutomataBase<Self>, T>::letter_delta(OutputIterator res,
00490                                                    hstate_t src,
00491                                                    const L& letter,
00492                                                    delta_kind::kind<Kind> k) const
00493   {
00494     op_letter_delta(this->structure(), this->value(), res, src, letter, k);
00495   }
00496 
00497   template <typename Self, typename T>
00498   template <typename OutputIterator, typename Kind>
00499   void
00500   MetaElement<AutomataBase<Self>, T>
00501   ::spontaneous_delta(OutputIterator res,
00502                       hstate_t src,
00503                       delta_kind::kind<Kind> k) const
00504   {
00505     return op_spontaneous_delta(this->structure(), this->value(), res, src, k);
00506   }
00507 
00508   /*----------.
00509   | Deltacs.  |
00510   `----------*/
00511 
00512   template <typename Self, typename T>
00513   template <typename Container, typename Kind>
00514   void
00515   MetaElement<AutomataBase<Self>, T>::deltac(Container& res, hstate_t src,
00516                                              delta_kind::kind<Kind> k) const
00517   {
00518     op_deltac(this->structure(), this->value(), res, src, k);
00519   }
00520 
00521   template <typename Self, typename T>
00522   template <typename Container, typename L, typename Kind>
00523   void
00524   MetaElement<AutomataBase<Self>, T>::deltac(Container& res,
00525                                              hstate_t src,
00526                                              const L& query,
00527                                              delta_kind::kind<Kind> k) const
00528   {
00529     op_deltac(this->structure(), this->value(), res, src, query, k);
00530   }
00531 
00532   template <typename Self, typename T>
00533   template <typename Container, typename L, typename Kind>
00534   void
00535   MetaElement<AutomataBase<Self>, T>::letter_deltac(Container& res,
00536                                                     hstate_t src,
00537                                                     const L& letter,
00538                                                     delta_kind::kind<Kind> k) const
00539   {
00540     op_letter_deltac(this->structure(), this->value(), res, src, letter, k);
00541   }
00542 
00543   template <typename Self, typename T>
00544   template <typename Container, typename Kind>
00545   void
00546   MetaElement<AutomataBase<Self>, T>
00547   ::spontaneous_deltac(Container& res,
00548                        hstate_t src,
00549                        delta_kind::kind<Kind> k) const
00550   {
00551     op_spontaneous_deltac(this->structure(), this->value(), res, src, k);
00552   }
00553 
00554   /*----------.
00555   | Deltafs.  |
00556   `----------*/
00557 
00558   template <typename Self, typename T>
00559   template <typename Functor, typename Kind>
00560   void
00561   MetaElement<AutomataBase<Self>, T>::deltaf(Functor& fun, hstate_t src,
00562                                              delta_kind::kind<Kind> k) const
00563   {
00564     op_deltaf(this->structure(), this->value(), fun, src, k);
00565   }
00566 
00567   template <typename Self, typename T>
00568   template <typename Functor, typename L, typename Kind>
00569   void
00570   MetaElement<AutomataBase<Self>, T>::deltaf(Functor& fun,
00571                                              hstate_t src,
00572                                              const L& query,
00573                                              delta_kind::kind<Kind> k) const
00574   {
00575     op_deltaf(this->structure(), this->value(), fun, src, query, k);
00576   }
00577 
00578   template <typename Self, typename T>
00579   template <typename Functor, typename L, typename Kind>
00580   void
00581   MetaElement<AutomataBase<Self>, T>::letter_deltaf(Functor& fun,
00582                                                     hstate_t src,
00583                                                     const L& letter,
00584                                                     delta_kind::kind<Kind> k) const
00585   {
00586     op_letter_deltaf(this->structure(), this->value(), fun, src, letter, k);
00587   }
00588 
00589   template <typename Self, typename T>
00590   template <typename Functor, typename Kind>
00591   void
00592   MetaElement<AutomataBase<Self>, T>
00593   ::spontaneous_deltaf(Functor& fun,
00594                        hstate_t src,
00595                        delta_kind::kind<Kind> k) const
00596   {
00597     op_spontaneous_deltaf(this->structure(), this->value(), fun, src, k);
00598   }
00599 
00600   /*-----------------.
00601   | Reverse deltas.  |
00602   `-----------------*/
00603 
00604   template <typename Self, typename T>
00605   template <typename OutputIterator, typename Kind>
00606   void
00607   MetaElement<AutomataBase<Self>, T>::rdelta(OutputIterator res,
00608                                              hstate_t src,
00609                                              delta_kind::kind<Kind> k) const
00610   {
00611     op_rdelta(this->structure(), this->value(), res, src, k);
00612   }
00613 
00614   template <typename Self, typename T>
00615   template <typename OutputIterator, typename L, typename Kind>
00616   void
00617   MetaElement<AutomataBase<Self>, T>::rdelta(OutputIterator res,
00618                                              hstate_t src,
00619                                              const L& query,
00620                                              delta_kind::kind<Kind> k) const
00621   {
00622     op_rdelta(this->structure(), this->value(), res, src, query, k);
00623   }
00624 
00625   template <typename Self, typename T>
00626   template <typename OutputIterator, typename L, typename Kind>
00627   void
00628   MetaElement<AutomataBase<Self>, T>::letter_rdelta(OutputIterator res,
00629                                                     hstate_t src,
00630                                                     const L& letter,
00631                                                     delta_kind::kind<Kind> k) const
00632   {
00633     op_letter_rdelta(this->structure(), this->value(), res, src, letter, k);
00634   }
00635 
00636   template <typename Self, typename T>
00637   template <typename OutputIterator, typename Kind>
00638   void
00639   MetaElement<AutomataBase<Self>, T>
00640   ::spontaneous_rdelta(OutputIterator res,
00641                        hstate_t src,
00642                        delta_kind::kind<Kind> k) const
00643   {
00644     return op_spontaneous_rdelta(this->structure(), this->value(), res, src, k);
00645   }
00646 
00647   /*------------------.
00648   | Reverse deltacs.  |
00649   `------------------*/
00650 
00651   template <typename Self, typename T>
00652   template <typename Container, typename Kind>
00653   void
00654   MetaElement<AutomataBase<Self>, T>::rdeltac(Container& res, hstate_t src,
00655                                               delta_kind::kind<Kind> k) const
00656   {
00657     op_rdeltac(this->structure(), this->value(), res, src, k);
00658   }
00659 
00660   template <typename Self, typename T>
00661   template <typename Container, typename L, typename Kind>
00662   void
00663   MetaElement<AutomataBase<Self>, T>::rdeltac(Container& res,
00664                                               hstate_t src,
00665                                               const L& query,
00666                                               delta_kind::kind<Kind> k) const
00667   {
00668     op_rdeltac(this->structure(), this->value(), res, src, query, k);
00669   }
00670 
00671   template <typename Self, typename T>
00672   template <typename Container, typename L, typename Kind>
00673   void
00674   MetaElement<AutomataBase<Self>, T>::letter_rdeltac(Container& res,
00675                                                      hstate_t src,
00676                                                      const L& letter,
00677                                                      delta_kind::kind<Kind> k) const
00678   {
00679     op_letter_rdeltac(this->structure(), this->value(), res, src, letter, k);
00680   }
00681 
00682   template <typename Self, typename T>
00683   template <typename Container, typename Kind>
00684   void
00685   MetaElement<AutomataBase<Self>, T>
00686   ::spontaneous_rdeltac(Container& res,
00687                         hstate_t src,
00688                         delta_kind::kind<Kind> k) const
00689   {
00690     op_spontaneous_rdeltac(this->structure(), this->value(), res, src, k);
00691   }
00692 
00693   /*------------------.
00694   | Reverse deltafs.  |
00695   `------------------*/
00696 
00697   template <typename Self, typename T>
00698   template <typename Functor, typename Kind>
00699   void
00700   MetaElement<AutomataBase<Self>, T>::rdeltaf(Functor& fun, hstate_t src,
00701                                               delta_kind::kind<Kind> k) const
00702   {
00703     op_rdeltaf(this->structure(), this->value(), fun, src, k);
00704   }
00705 
00706   template <typename Self, typename T>
00707   template <typename Functor, typename L, typename Kind>
00708   void
00709   MetaElement<AutomataBase<Self>, T>::rdeltaf(Functor& fun,
00710                                               hstate_t src,
00711                                               const L& query,
00712                                               delta_kind::kind<Kind> k) const
00713   {
00714     op_rdeltaf(this->structure(), this->value(), fun, src, query, k);
00715   }
00716 
00717   template <typename Self, typename T>
00718   template <typename Functor, typename L, typename Kind>
00719   void
00720   MetaElement<AutomataBase<Self>, T>::letter_rdeltaf(Functor& fun,
00721                                                      hstate_t src,
00722                                                      const L& letter,
00723                                                      delta_kind::kind<Kind> k) const
00724   {
00725     op_letter_rdeltaf(this->structure(), this->value(), fun, src, letter, k);
00726   }
00727 
00728   template <typename Self, typename T>
00729   template <typename Functor, typename Kind>
00730   void
00731   MetaElement<AutomataBase<Self>, T>
00732   ::spontaneous_rdeltaf(Functor& fun,
00733                         hstate_t src,
00734                         delta_kind::kind<Kind> k) const
00735   {
00736     op_spontaneous_rdeltaf(this->structure(), this->value(), fun, src, k);
00737   }
00738 
00739 
00740 
00741   template<typename S, typename St, typename T>
00742   St& op_rout(const AutomataBase<S>& s, St& st, const T& v)
00743   {
00744     Element<S, T> r(s.self(), v);
00745     st << "{ "
00746        << r.states().size() << " states, "
00747        << r.transitions().size() << " transitions, "
00748        << "#I = " << r.initial().size() << ", "
00749        << "#T = " << r.final().size()
00750        << " }";
00751     return st;
00752   }
00753 
00754 
00755 } // vcsn
00756 
00757 #endif // ! VCSN_AUTOMATA_CONCEPT_AUTOMATA_BASE_HXX