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

# transpose_view.hxx

    00001 // transpose_view.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_IMPLEMENTATION_TRANSPOSE_VIEW_HXX
    00018 # define VCSN_AUTOMATA_IMPLEMENTATION_TRANSPOSE_VIEW_HXX
    00019
    00020 # include <vaucanson/automata/implementation/transpose_view.hh>
    00021
    00022 namespace vcsn {
    00023
    00024 #define AutoType(Type)                          \
    00025   typename Element<S, TransposeView<T> >::Type
    00026
    00027   template <class T>
    00028   TransposeView<T>::TransposeView()
    00029   {}
    00030
    00031   template <class T>
    00032   TransposeView<T>::TransposeView(const T& object):
    00033     IdentityView<T>(object)
    00034   {}
    00035
    00036   template <class T>
    00037   TransposeView<T>::TransposeView(T& object):
    00038     IdentityView<T>(object)
    00039   {}
    00040
    00041   template <class T>
    00042   TransposeView<T>::TransposeView(const TransposeView& t):
    00043     IdentityView<T>(t)
    00044   {}
    00045
    00046   template <class S, class T>
    00047   Element<S, TransposeView<T> >
    00048   transpose_view(Element<S, T>& a)
    00049   {
    00050     return Element<S, TransposeView<T> >
    00051       (a.structure(), TransposeView<T>(a.value()));
    00052   }
    00053
    00054   template <class S, class T>
    00055   const Element<S, TransposeView<T> >
    00056   transpose_view(const Element<S, T>& a)
    00057   {
    00058     return Element<S, TransposeView<T> >
    00059       (a.structure(), TransposeView<T>(a.value()));
    00060   }
    00061
    00062   template <class S, class T>
    00063   const typename automaton_traits<T>::tag_t&
    00064   op_get_tag(const AutomataBase<S>& s, const TransposeView<T>& v)
    00065   {
    00066     return op_get_tag(s, v.object());
    00067   }
    00068
    00069   template <class S, class T>
    00070   typename automaton_traits<T>::tag_t&
    00071   op_get_tag(const AutomataBase<S>& s, TransposeView<T>& v)
    00072   {
    00073     return op_get_tag(s, v.object());
    00074   }
    00075
    00076   template <class S, class T>
    00077   const typename automaton_traits<T>::geometry_t&
    00078   op_get_geometry(const AutomataBase<S>& s, const TransposeView<T>& v)
    00079   {
    00080     return op_get_geometry(s, v.object());
    00081   }
    00082
    00083   template <class S, class T>
    00084   typename automaton_traits<T>::geometry_t&
    00085   op_get_geometry(const AutomataBase<S>& s, TransposeView<T>& v)
    00086   {
    00087     return op_get_geometry(s, v.object());
    00088   }
    00089
    00090   template <class S, class T>
    00091   bool
    00092   op_exists(const AutomataBase<S>& s, const TransposeView<T>& v)
    00093   {
    00094     return op_exists(s, v.object());
    00095   }
    00096
    00097   template <class S, class T>
    00098   typename automaton_traits<T>::states_t
    00099   op_states(const AutomataBase<S>& s, const TransposeView<T>& v)
    00100   {
    00101     return op_states(s, v.object());
    00102   }
    00103
    00104   template <class S, class T>
    00105   typename automaton_traits<T>::transitions_t
    00106   op_transitions(const AutomataBase<S>& s, const TransposeView<T>& v)
    00107   {
    00108     return op_transitions(s, v.object());
    00109   }
    00110
    00111   template <class S, class T>
    00112   hstate_t
    00113   op_add_state(const AutomataBase<S>& s, TransposeView<T>& v)
    00114   {
    00115     return op_add_state(s, v.object());
    00116   }
    00117
    00118   template <class S, class T>
    00119   hstate_t
    00120   op_choose_state(const AutomataBase<S>& s, TransposeView<T>& v)
    00121   {
    00122     return op_choose_state(s, v.object());
    00123   }
    00124
    00125   template <class S, class T>
    00126   htransition_t
    00127   op_add_transition(const AutomataBase<S>& s, TransposeView<T>& v,
    00128                     hstate_t from,
    00129                     hstate_t to,
    00130                     const typename Element<S, T>::label_t& label)
    00131   {
    00132     return op_add_transition(s, v.object(), from, to, label);
    00133   }
    00134
    00135   template <class S, class T>
    00136   htransition_t
    00137   op_add_series_transition(const AutomataBase<S>& s,
    00138                            TransposeView<T>& v,
    00139                            hstate_t from,
    00140                            hstate_t to,
    00141                            const typename Element<S, T>::series_set_elt_t& se)
    00142   {
    00143     return op_add_series_transition(s, v.object(), from, to, se);
    00144   }
    00145
    00146   template <class S, class T>
    00147   htransition_t
    00148   op_add_spontaneous(const AutomataBase<S>& s, TransposeView<T>& v,
    00149                      hstate_t from,
    00150                      hstate_t to)
    00151   {
    00152     return op_add_spontaneous(s, v.object(), from, to);
    00153   }
    00154
    00155   template <class S, class T>
    00156   htransition_t
    00157   op_add_letter_transition(const AutomataBase<S>& s, TransposeView<T>& v,
    00158                            hstate_t from,
    00159                            hstate_t to,
    00160                            const typename Element<S, T>::letter_t& e)
    00161   {
    00162     return op_add_letter_transition(s, v.object(), from, to, e);
    00163   }
    00164
    00165   template <class S, class T>
    00166   void
    00167   op_update(const AutomataBase<S>& s, TransposeView<T>& v,
    00168             htransition_t e,
    00169             const AutoType(label_t)& l)
    00170   {
    00171     op_update(s, v.object(), e, l);
    00172   }
    00173
    00174   template <class S, class T>
    00175   void
    00176   op_del_state(const AutomataBase<S>& s, TransposeView<T>& v,
    00177                hstate_t st)
    00178   {
    00179     op_del_state(s, v.object(), st);
    00180   }
    00181
    00182   template <class S, class T>
    00183   void
    00184   op_del_transition(const AutomataBase<S>& s, TransposeView<T>& v,
    00185                     htransition_t e)
    00186   {
    00187     op_del_transition(s, v.object(), e);
    00188   }
    00189
    00190   template <class S, class T>
    00191   bool
    00192   op_has_state(const AutomataBase<S>& s,
    00193                const TransposeView<T>& v,
    00194                hstate_t st)
    00195   {
    00196     return op_has_state(s, v.object(), st);
    00197   }
    00198
    00199   template <class S, class T>
    00200   bool
    00201   op_has_transition(const AutomataBase<S>& s,
    00202                     const TransposeView<T>& v,
    00203                     htransition_t e)
    00204   {
    00205     return op_has_transition(s, v.object(), e);
    00206   }
    00207
    00208   template <class S, class T>
    00209   typename Element<S, T>::label_t
    00210   op_label_of(const AutomataBase<S>& s,
    00211               const TransposeView<T>& v,
    00212               htransition_t e)
    00213   {
    00214     return op_label_of(s, v.object(), e);
    00215   }
    00216
    00217   template <class S, class T>
    00218   const typename Element<S, T>::series_set_elt_t
    00219   op_series_of(const AutomataBase<S>& s,
    00220                const TransposeView<T>& v,
    00221                htransition_t e)
    00222   {
    00223     typename Element<S, T>::series_set_elt_t r =
    00224       op_series_of(s, v.object(), e);
    00225     r.transpose();
    00226     return r;
    00227   }
    00228
    00229   template <class S, class T>
    00230   typename Element<S, T>::series_set_elt_value_t
    00231   op_series_value_of(const AutomataBase<S>& s,
    00232                      const TransposeView<T>& v,
    00233                      htransition_t e)
    00234   {
    00235     return op_series_value_of(s, v.object(), e);
    00236   }
    00237
    00238   template <class S, class T>
    00239   typename Element<S, T>::monoid_elt_t
    00240   op_word_of(const AutomataBase<S>& s,
    00241              const TransposeView<T>& v,
    00242              htransition_t e)
    00243   {
    00244     return op_word_of(s, v.object(), e);
    00245   }
    00246
    00247   template <class S, class T>
    00248   typename Element<S, T>::monoid_elt_value_t
    00249   op_word_value_of(const AutomataBase<S>& s,
    00250                    const TransposeView<T>& v,
    00251                    htransition_t e)
    00252   {
    00253     return op_word_value_of(s, v.object(), e);
    00254   }
    00255
    00256   template <class S, class T>
    00257   typename Element<S, T>::letter_t
    00258   op_letter_of(const AutomataBase<S>& s,
    00259                const TransposeView<T>& v,
    00260                htransition_t e)
    00261   {
    00262     return op_letter_of(s, v.object(), e);
    00263   }
    00264
    00265   template <class S, class T>
    00266   bool
    00267   op_is_spontaneous(const AutomataBase<S>& s,
    00268                     const TransposeView<T>& v,
    00269                     htransition_t e)
    00270   {
    00271     return op_is_spontaneous(s, v.object(), e);
    00272   }
    00273
    00274   template <class S, class T>
    00275   typename automaton_traits<TransposeView<T> >::initial_support_t
    00276   op_initial(const AutomataBase<S>& s, const TransposeView<T>& v)
    00277   {
    00278     return op_final(s, v.object());
    00279   }
    00280
    00281   template <class S, class T>
    00282   typename automaton_traits<TransposeView<T> >::final_support_t
    00283   op_final(const AutomataBase<S>& s, const TransposeView<T>& v)
    00284   {
    00285     return op_initial(s, v.object());
    00286   }
    00287
    00288   template <class S, class T>
    00289   void
    00290   op_set_initial(const AutomataBase<S>& ss, TransposeView<T>& v,
    00291                  hstate_t state,
    00292                  const AutoType(series_set_elt_t)& s)
    00293   {
    00294     return op_set_final(ss, v.object(), state, s);
    00295   }
    00296
    00297   template <class S, class T>
    00298   AutoType(series_set_elt_t)
    00299   op_get_initial(const AutomataBase<S>& s,
    00300                  const TransposeView<T>& v,
    00301                  hstate_t state)
    00302   {
    00303     AutoType(series_set_elt_t) r = op_get_final(s, v.object(), state);
    00304     r.transpose();
    00305     return r;
    00306   }
    00307
    00308   template <class S, class T>
    00309   void
    00310   op_set_final(const AutomataBase<S>& ss, TransposeView<T>& v,
    00311                hstate_t state,
    00312                const typename Element<S, T>::series_set_elt_t& s)
    00313   {
    00314     op_set_initial(ss, v.object(), state, s);
    00315   }
    00316
    00317   template <class S, class T>
    00318   typename Element<S, T>::series_set_elt_t
    00319   op_get_final(const AutomataBase<S>& s,
    00320                const TransposeView<T>& v,
    00321                hstate_t state)
    00322   {
    00323     typename Element<S, T>::series_set_elt_t r = op_get_initial(s, v.object(),
    00324                                                                 state);
    00325     r.transpose();
    00326     return r;
    00327   }
    00328
    00329   template <class S, class T>
    00330   void
    00331   op_clear_initial(const AutomataBase<S>& s, TransposeView<T>& v)
    00332   {
    00333     op_clear_final(s, v.object());
    00334   }
    00335
    00336   template <class S, class T>
    00337   void
    00338   op_clear_final(const AutomataBase<S>& s, TransposeView<T>& v)
    00339   {
    00340     op_clear_initial(s, v.object());
    00341   }
    00342
    00343   template <class S, class T>
    00344   hstate_t
    00345   op_src_of(const AutomataBase<S>& s,
    00346             const TransposeView<T>& v,
    00347             htransition_t e)
    00348   {
    00349     return op_dst_of(s, v.object(), e);
    00350   }
    00351
    00352   template <class S, class T>
    00353   hstate_t
    00354   op_dst_of(const AutomataBase<S>& s,
    00355             const TransposeView<T>& v,
    00356             htransition_t e)
    00357   {
    00358     return op_src_of(s, v.object(), e);
    00359   }
    00360
    00361   // output_return_type = OutputIterator
    00362   // output_type        = htransition_t
    00363   // direction          = output
    00364
    00365   template <class S, class T,
    00366             typename OutputIterator>
    00367   void op_delta(const AutomataBase<S>& s,
    00368                 const TransposeView<T>& v,
    00369                 OutputIterator res,
    00370                 hstate_t from,
    00371                 delta_kind::transitions k)
    00372   {
    00373     op_rdelta(s, v.object(), res, from, k);
    00374   }
    00375
    00376   template <class S, class T,
    00377             typename OutputIterator, typename L>
    00378   void op_delta(const AutomataBase<S>& s,
    00379                 const TransposeView<T>& v,
    00380                 OutputIterator res,
    00381                 hstate_t from,
    00382                 const L& query,
    00383                 delta_kind::transitions k)
    00384   {
    00385     op_rdelta(s, v.object(), res, from, query, k);
    00386   }
    00387
    00388   template <class S, class T,
    00389             typename OutputIterator, typename L>
    00390   void op_letter_delta(const AutomataBase<S>& s,
    00391                        const TransposeView<T>& v,
    00392                        OutputIterator res,
    00393                        hstate_t from,
    00394                        const L& letter,
    00395                        delta_kind::transitions k)
    00396   {
    00397     op_letter_rdelta(s, v.object(), res, from, letter, k);
    00398   }
    00399
    00400   template <class S, class T,
    00401             typename OutputIterator>
    00402   void op_spontaneous_delta(const AutomataBase<S>& s,
    00403                             const TransposeView<T>& v,
    00404                             OutputIterator res,
    00405                             hstate_t from,
    00406                             delta_kind::transitions k)
    00407   {
    00408     op_spontaneous_rdelta(s, v.object(), res, from, k);
    00409   }
    00410
    00411   // output_return_type = Container
    00412   // output_type        = htransition_t
    00413   // direction          = output
    00414
    00415   template <class S, class T,
    00416             typename Container>
    00417   void op_deltac(const AutomataBase<S>& s,
    00418                  const TransposeView<T>& v,
    00419                  Container& res, hstate_t from, delta_kind::transitions k)
    00420   {
    00421     op_rdeltac(s, v.object(), res, from, k);
    00422   }
    00423
    00424   template <class S, class T,
    00425             typename Container, typename L>
    00426   void op_deltac(const AutomataBase<S>& s,
    00427                  const TransposeView<T>& v,
    00428                  Container& res,
    00429                  hstate_t from,
    00430                  const L& query,
    00431                  delta_kind::transitions k)
    00432   {
    00433     op_rdeltac(s, v.object(), res, from, query, k);
    00434   }
    00435
    00436   template <class S, class T,
    00437             typename Container, typename L>
    00438   void op_letter_deltac(const AutomataBase<S>& s,
    00439                         const TransposeView<T>& v,
    00440                         Container& res,
    00441                         hstate_t from,
    00442                         const L& letter,
    00443                         delta_kind::transitions k)
    00444   {
    00445     op_letter_rdeltac(s, v.object(), res, from, letter, k);
    00446   }
    00447
    00448   template <class S, class T, class Container>
    00449   void op_spontaneous_deltac(const AutomataBase<S>& s,
    00450                              const TransposeView<T>& v,
    00451                              Container& res,
    00452                              hstate_t from,
    00453                              delta_kind::transitions k)
    00454   {
    00455     op_spontaneous_rdeltac(s, v.object(), res, from, k);
    00456   }
    00457
    00458   // output_return_type = OutputIterator
    00459   // output_type        = hstate_t
    00460   // direction          = output
    00461
    00462   template<class S, class T, typename OutputIterator>
    00463   void op_delta(const AutomataBase<S>& s,
    00464                 const TransposeView<T>& v,
    00465                 OutputIterator res,
    00466                 hstate_t from,
    00467                 delta_kind::states k)
    00468   {
    00469     op_rdelta(s, v.object(), res, from, k);
    00470   }
    00471
    00472   template<class S, class T, typename OutputIterator, typename L>
    00473   void op_delta(const AutomataBase<S>& s,
    00474                 const TransposeView<T>& v,
    00475                 OutputIterator res,
    00476                 hstate_t from,
    00477                 const L& query,
    00478                 delta_kind::states k)
    00479   {
    00480     op_rdelta(s, v.object(), res, from, query, k);
    00481   }
    00482
    00483   template<class S, class T, typename OutputIterator, typename L>
    00484   void op_letter_delta(const AutomataBase<S>& s,
    00485                        const TransposeView<T>& v,
    00486                        OutputIterator res,
    00487                        hstate_t from,
    00488                        const L& letter,
    00489                        delta_kind::states k)
    00490   {
    00491     op_letter_rdelta(s, v.object(), res, from, letter, k);
    00492   }
    00493
    00494   template<class S, class T, typename OutputIterator>
    00495   void op_spontaneous_delta(const AutomataBase<S>& s,
    00496                             const TransposeView<T>& v,
    00497                             OutputIterator res,
    00498                             hstate_t from,
    00499                             delta_kind::states k)
    00500   {
    00501     op_spontaneous_rdelta(s, v.object(), res, from, k);
    00502   }
    00503
    00504   // output_return_type = Container
    00505   // output_type        = hstate_t
    00506   // direction          = output
    00507
    00508   template<class S, class T, typename Container>
    00509   void op_deltac(const AutomataBase<S>& s,
    00510                  const TransposeView<T>& v,
    00511                  Container& res, hstate_t from, delta_kind::states k)
    00512   {
    00513     op_rdeltac(s, v.object(), res, from, k);
    00514   }
    00515
    00516   template<class S, class T, typename Container, typename L>
    00517   void op_deltac(const AutomataBase<S>& s,
    00518                  const TransposeView<T>& v,
    00519                  Container& res,
    00520                  hstate_t from,
    00521                  const L& query,
    00522                  delta_kind::states k)
    00523   {
    00524     op_rdeltac(s, v.object(), res, from, k);
    00525   }
    00526
    00527   template<class S, class T, typename Container, typename L>
    00528   void op_letter_deltac(const AutomataBase<S>& s,
    00529                         const TransposeView<T>& v,
    00530                         Container& res,
    00531                         hstate_t from,
    00532                         const L& letter,
    00533                         delta_kind::states k)
    00534   {
    00535     op_letter_rdeltac(s, v.object(), res, from, letter, k);
    00536   }
    00537
    00538   template<class S, class T, typename Container>
    00539   void op_spontaneous_deltac(const AutomataBase<S>& s,
    00540                              const TransposeView<T>& v,
    00541                              Container& res,
    00542                              hstate_t from,
    00543                              delta_kind::states k)
    00544   {
    00545     op_spontaneous_rdeltac(s, v.object(), res, from, k);
    00546   }
    00547
    00548   // output_return_type = OutputIterator
    00549   // output_type        = htransition_t
    00550   // direction          = input
    00551
    00552   template<class S, class T, typename OutputIterator>
    00553   void op_rdelta(const AutomataBase<S>& s, const TransposeView<T>& v,
    00554                  OutputIterator res,
    00555                  hstate_t from,
    00556                  delta_kind::transitions k)
    00557   {
    00558     op_delta(s, v.object(), res, from, k);
    00559   }
    00560
    00561   template<class S, class T, typename OutputIterator, typename L>
    00562   void op_rdelta(const AutomataBase<S>& s, const TransposeView<T>& v,
    00563                  OutputIterator res,
    00564                  hstate_t from,
    00565                  const L& query,
    00566                  delta_kind::transitions k)
    00567   {
    00568     op_delta(s, v.object(), res, from, query, k);
    00569   }
    00570
    00571   template<class S, class T, typename OutputIterator, typename L>
    00572   void op_letter_rdelta(const AutomataBase<S>& s, const TransposeView<T>& v,
    00573                         OutputIterator res,
    00574                         hstate_t from,
    00575                         const L& letter,
    00576                         delta_kind::transitions k)
    00577   {
    00578     op_letter_delta(s, v.object(), res, from, letter, k);
    00579   }
    00580
    00581   template<class S, class T, typename OutputIterator>
    00582   void op_spontaneous_rdelta(const AutomataBase<S>& s,
    00583                              const TransposeView<T>& v,
    00584                              OutputIterator res,
    00585                              hstate_t from,
    00586                              delta_kind::transitions k)
    00587   {
    00588     op_spontaneous_delta(s, v.object(), res, from, k);
    00589   }
    00590
    00591   // output_return_type = Container
    00592   // output_type        = htransition_t
    00593   // direction          = input
    00594
    00595   template<class S, class T, typename Container>
    00596   void op_rdeltac(const AutomataBase<S>& s, const TransposeView<T>& v,
    00597                   Container& res, hstate_t from, delta_kind::transitions k)
    00598   {
    00599     op_deltac(s, v.object(), res, from, k);
    00600   }
    00601
    00602   template<class S, class T, typename Container, typename L>
    00603   void op_rdeltac(const AutomataBase<S>& s, const TransposeView<T>& v,
    00604                   Container& res,
    00605                   hstate_t from,
    00606                   const L& query,
    00607                   delta_kind::transitions k)
    00608   {
    00609     op_deltac(s, v.object(), res, from, query, k);
    00610   }
    00611
    00612   template<class S, class T, typename Container, typename L>
    00613   void op_letter_rdeltac(const AutomataBase<S>& s, const TransposeView<T>& v,
    00614                          Container& res,
    00615                          hstate_t from,
    00616                          const L& letter,
    00617                          delta_kind::transitions k)
    00618   {
    00619     op_letter_deltac(s, v.object(), res, from, letter, k);
    00620   }
    00621
    00622   template<class S, class T, typename Container>
    00623   void op_spontaneous_rdeltac(const AutomataBase<S>& s,
    00624                               const TransposeView<T>& v,
    00625                               Container& res,
    00626                               hstate_t from,
    00627                               delta_kind::transitions k)
    00628   {
    00629     op_spontaneous_deltac(s, v.object(), res, from, k);
    00630   }
    00631
    00632   // output_return_type = OutputIterator
    00633   // output_type        = hstate_t
    00634   // direction          = input
    00635
    00636   template<class S, class T, typename OutputIterator>
    00637   void op_rdelta(const AutomataBase<S>& s, const TransposeView<T>& v,
    00638                  OutputIterator res,
    00639                  hstate_t from,
    00640                  delta_kind::states k)
    00641   {
    00642     op_delta(s, v.object(), res, from, k);
    00643   }
    00644
    00645   template<class S, class T, typename OutputIterator, typename L>
    00646   void op_rdelta(const AutomataBase<S>& s, const TransposeView<T>& v,
    00647                  OutputIterator res,
    00648                  hstate_t from,
    00649                  const L& query,
    00650                  delta_kind::states k)
    00651   {
    00652     op_delta(s, v.object(), res, from, query, k);
    00653   }
    00654
    00655   template<class S, class T, typename OutputIterator, typename L>
    00656   void op_letter_rdelta(const AutomataBase<S>& s, const TransposeView<T>& v,
    00657                         OutputIterator res,
    00658                         hstate_t from,
    00659                         const L& letter,
    00660                         delta_kind::states k)
    00661   {
    00662     op_letter_delta(s, v.object(), res, from, letter, k);
    00663   }
    00664
    00665   template<class S, class T, typename OutputIterator>
    00666   void op_spontaneous_rdelta(const AutomataBase<S>& s,
    00667                              const TransposeView<T>& v,
    00668                              OutputIterator res,
    00669                              hstate_t from,
    00670                              delta_kind::states k)
    00671   {
    00672     op_spontaneous_delta(s, v.object(), res, from, k);
    00673   }
    00674
    00675   // output_return_type = Container
    00676   // output_type        = hstate_t
    00677   // direction          = input
    00678
    00679   template<class S, class T, typename Container>
    00680   void op_rdeltac(const AutomataBase<S>& s, const TransposeView<T>& v,
    00681                   Container& res, hstate_t from, delta_kind::states k)
    00682   {
    00683     op_deltac(s, v.object(), res, from, k);
    00684   }
    00685
    00686   template<class S, class T, typename Container, typename L>
    00687   void op_rdeltac(const AutomataBase<S>& s, const TransposeView<T>& v,
    00688                   Container& res,
    00689                   hstate_t from,
    00690                   const L& query,
    00691                   delta_kind::states k)
    00692   {
    00693     op_deltac(s, v.object(), res, from, query, k);
    00694   }
    00695
    00696   template<class S, class T, typename Container, typename L>
    00697   void op_letter_rdeltac(const AutomataBase<S>& s, const TransposeView<T>& v,
    00698                          Container& res,
    00699                          hstate_t from,
    00700                          const L& letter,
    00701                          delta_kind::states k)
    00702   {
    00703     op_letter_deltac(s, v.object(), res, from, letter, k);
    00704   }
    00705
    00706   template<class S, class T, typename Container>
    00707   void op_spontaneous_rdeltac(const AutomataBase<S>& s,
    00708                               const TransposeView<T>& v,
    00709                               Container& res,
    00710                               hstate_t from,
    00711                               delta_kind::states k)
    00712   {
    00713     op_spontaneous_deltac(s, v.object(), res, from, k);
    00714   }
    00715
    00716 } // vcsn
    00717
    00718 # undef AutoType
    00719
    00720 #endif // ! VCSN_AUTOMATA_IMPLEMENTATION_TRANSPOSE_VIEW_HXX