Vaucanson: automaton_view.hxx Source File

00001 // automaton_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_AUTOMATON_VIEW_HXX
00018 # define VCSN_AUTOMATA_IMPLEMENTATION_AUTOMATON_VIEW_HXX
00019 
00020 # include <vaucanson/misc/contract.hh>
00021 # include <vaucanson/automata/implementation/automaton_view.hh>
00022 
00023 #define AutoType(Type)                          \
00024   typename Element<S, IdentityView<T> >::Type
00025 
00026 namespace vcsn {
00027 
00028   template <class T>
00029   IdentityView<T>::IdentityView():
00030     object_(0),
00031     const_object_(0)
00032   {}
00033 
00034   template <class T>
00035   IdentityView<T>::IdentityView(T& d):
00036     object_(&d),
00037     const_object_(0)
00038   {}
00039 
00040   template <class T>
00041   IdentityView<T>::IdentityView(const T& d):
00042     object_(0),
00043     const_object_(&d)
00044   {}
00045 
00046   template <class T>
00047   IdentityView<T>::IdentityView(const IdentityView& d):
00048     object_(0)
00049   {
00050     assertion(d.object_ != 0 || d.const_object_ != 0);
00051     const_object_ = d.const_object_ == 0 ? d.object_ : d.const_object_;
00052   }
00053 
00054   template <class T>
00055   const T&
00056   IdentityView<T>::object() const
00057   {
00058     assertion(object_ != 0 || const_object_ != 0);
00059     return const_object_ == 0 ? *object_ : *const_object_;
00060   }
00061 
00062   template <class T>
00063   T&
00064   IdentityView<T>::object()
00065   {
00066     assertion(object_ != 0);
00067     assertion(const_object_ == 0);
00068     return *object_;
00069   }
00070 
00071   template <class T>
00072   IdentityView<T>::operator T&()
00073   {
00074     assertion(object_ != 0);
00075     assertion(const_object_ == 0);
00076     return *object_;
00077   }
00078 
00079   template <class T>
00080   IdentityView<T>::operator const T&() const
00081   {
00082     assertion(object_ != 0 || const_object_ != 0);
00083     return const_object_ == 0 ? *object_ : *const_object_;
00084   }
00085 
00086   template <class S, class T>
00087   const typename automaton_traits<T>::tag_t&
00088   op_get_tag(const AutomataBase<S>& s, const IdentityView<T>& v)
00089   {
00090     return op_get_tag(s, v.object());
00091   }
00092 
00093   template <class S, class T>
00094   typename automaton_traits<T>::tag_t&
00095   op_get_tag(const AutomataBase<S>& s, IdentityView<T>& v)
00096   {
00097     return op_get_tag(s, v.object());
00098   }
00099 
00100   template <class S, class T>
00101   const typename automaton_traits<T>::geometry_t&
00102   op_get_geometry(const AutomataBase<S>& s, const IdentityView<T>& v)
00103   {
00104     return op_get_geometry(s, v.object());
00105   }
00106 
00107   template <class S, class T>
00108   typename automaton_traits<T>::geometry_t&
00109   op_get_geometry(const AutomataBase<S>& s, IdentityView<T>& v)
00110   {
00111     return op_get_geometry(s, v.object());
00112   }
00113 
00114   template <class S, class T>
00115   bool
00116   op_exists(const AutomataBase<S>& s, const IdentityView<T>& v)
00117   {
00118     return op_exists(s, v.object());
00119   }
00120 
00121   template <class S, class T>
00122   typename automaton_traits<T>::states_t
00123   op_states(const AutomataBase<S>& s, const IdentityView<T>& v)
00124   {
00125     return op_states(s, v.object());
00126   }
00127 
00128   template <class S, class T>
00129   typename automaton_traits<T>::transitions_t
00130   op_transitions(const AutomataBase<S>& s, const IdentityView<T>& v)
00131   {
00132     return op_transitions(s, v.object());
00133   }
00134 
00135   template <class S, class T>
00136   typename automaton_traits<T>::initial_support_t
00137   op_initial(const AutomataBase<S>& s, const IdentityView<T>& v)
00138   {
00139     return op_initial(s, v.object());
00140   }
00141 
00142   template <class S, class T>
00143   typename automaton_traits<T>::final_support_t
00144   op_final(const AutomataBase<S>& s, const IdentityView<T>& v)
00145   {
00146     return op_final(s, v.object());
00147   }
00148 
00149   template <class S, class T>
00150   void
00151   op_set_initial(const AutomataBase<S>& ss, IdentityView<T>& v,
00152                  const typename automaton_traits<T>::hstate_t& state,
00153                  const AutoType(series_set_elt_t)& s)
00154   {
00155     return op_set_initial(ss, v.object(), state, s);
00156   }
00157 
00158   template <class S, class T>
00159   AutoType(series_set_elt_t)
00160   op_get_initial(const AutomataBase<S>& s,
00161                  const IdentityView<T>& v,
00162                  const typename automaton_traits<T>::hstate_t& state)
00163   {
00164     return op_get_initial(s, v.object(), state);
00165   }
00166 
00167   template <class S, class T>
00168   void
00169   op_set_final(const AutomataBase<S>& ss, IdentityView<T>& v,
00170                const typename automaton_traits<T>::hstate_t& state,
00171                const typename Element<S, T>::series_set_elt_t& s)
00172   {
00173     op_set_final(ss, v.object, state, s);
00174   }
00175 
00176   template <class S, class T>
00177   typename Element<S, T>::series_set_elt_t
00178   op_get_final(const AutomataBase<S>& s,
00179                const IdentityView<T>& v,
00180                const typename automaton_traits<T>::hstate_t& state)
00181   {
00182     return op_get_final(s, v.object, state);
00183   }
00184 
00185   template <class S, class T>
00186   void
00187   op_clear_initial(const AutomataBase<S>& s, IdentityView<T>& v)
00188   {
00189     op_clear_initial(s, v.object);
00190   }
00191 
00192   template <class S, class T>
00193   void
00194   op_clear_final(const AutomataBase<S>& s, IdentityView<T>& v)
00195   {
00196     op_clear_final(s, v.object());
00197   }
00198 
00199   template <class S, class T>
00200   typename automaton_traits<T>::hstate_t
00201   op_add_state(const AutomataBase<S>& s, IdentityView<T>& v)
00202   {
00203     return op_add_state(s, v.object());
00204   }
00205 
00206   template <class S, class T>
00207   typename automaton_traits<T>::hstate_t
00208   op_choose_state(const AutomataBase<S>& s, IdentityView<T>& v)
00209   {
00210     return op_choose_state(s, v.object());
00211   }
00212 
00213   template <class S, class T>
00214   typename automaton_traits<T>::htransition_t
00215   op_add_transition(const AutomataBase<S>& s, IdentityView<T>& v,
00216                     const typename automaton_traits<T>::hstate_t& from,
00217                     const typename automaton_traits<T>::hstate_t& to,
00218                     const typename Element<S, T>::label_t& label)
00219   {
00220     return op_add_transition(s, v.object(), from, to, label);
00221   }
00222 
00223   template <class S, class T>
00224   typename automaton_traits<T>::htransition_t
00225   op_add_series_transition(const AutomataBase<S>& s,
00226                            IdentityView<T>& v,
00227                            const typename automaton_traits<T>::hstate_t& from,
00228                            const typename automaton_traits<T>::hstate_t& to,
00229                            const typename Element<S, T>::series_set_elt_t& se)
00230   {
00231     return op_add_series_transition(s, v.object(), from, to, se);
00232   }
00233 
00234   template <class S, class T>
00235   typename automaton_traits<T>::htransition_t
00236   op_add_spontaneous(const AutomataBase<S>& s, IdentityView<T>& v,
00237                      const typename automaton_traits<T>::hstate_t& from,
00238                      const typename automaton_traits<T>::hstate_t& to)
00239   {
00240     return op_add_spontaneous(s, v.object(), from, to);
00241   }
00242 
00243   template <class S, class T>
00244   typename automaton_traits<T>::htransition_t
00245   op_add_letter_transition(const AutomataBase<S>& s, IdentityView<T>& v,
00246                            const typename automaton_traits<T>::hstate_t& from,
00247                            const typename automaton_traits<T>::hstate_t& to,
00248                            const typename Element<S, T>::letter_t& e)
00249   {
00250     return op_add_letter_transition(s, v.object(), from, to, e);
00251   }
00252 
00253   template <class S, class T>
00254   void
00255   op_update(const AutomataBase<S>& s, IdentityView<T>& v,
00256             const typename automaton_traits<T>::htransition_t& e,
00257             const AutoType(label_t)& l)
00258   {
00259     op_update(s, v.object(), e, l);
00260   }
00261 
00262   template <class S, class T>
00263   void
00264   op_del_state(const AutomataBase<S>& s, IdentityView<T>& v,
00265                const typename automaton_traits<T>::hstate_t& st)
00266   {
00267     op_del_state(s, v.object(), st);
00268   }
00269 
00270   template <class S, class T>
00271   void
00272   op_del_transition(const AutomataBase<S>& s, IdentityView<T>& v,
00273                     const typename automaton_traits<T>::htransition_t& e)
00274   {
00275     op_del_transition(s, v.object(), e);
00276   }
00277 
00278   template <class S, class T>
00279   bool
00280   op_has_state(const AutomataBase<S>& s,
00281                const IdentityView<T>& v,
00282                const typename automaton_traits<T>::hstate_t& st)
00283   {
00284     return op_has_state(s, v.object(), st);
00285   }
00286 
00287   template <class S, class T>
00288   bool
00289   op_has_transition(const AutomataBase<S>& s,
00290                     const IdentityView<T>& v,
00291                     const typename automaton_traits<T>::htransition_t& e)
00292   {
00293     return op_has_transition(s, v.object(), e);
00294   }
00295 
00296   template <class S, class T>
00297   typename automaton_traits<T>::hstate_t
00298   op_src_of(const AutomataBase<S>& s,
00299             const IdentityView<T>& v,
00300             const typename automaton_traits<T>::htransition_t& e)
00301   {
00302     return op_src_of(s, v.object(), e);
00303   }
00304 
00305   template <class S, class T>
00306   typename automaton_traits<T>::hstate_t
00307   op_dst_of(const AutomataBase<S>& s,
00308             const IdentityView<T>& v,
00309             const typename automaton_traits<T>::htransition_t& e)
00310   {
00311     return op_dst_of(s, v.object(), e);
00312   }
00313 
00314   template <class S, class T>
00315   typename Element<S, T>::label_t
00316   op_label_of(const AutomataBase<S>& s,
00317               const IdentityView<T>& v,
00318               const typename automaton_traits<T>::htransition_t& e)
00319   {
00320     return op_label_of(s, v.object(), e);
00321   }
00322 
00323   template <class S, class T>
00324   const typename Element<S, T>::series_set_elt_t
00325   op_series_of(const AutomataBase<S>& s,
00326                const IdentityView<T>& v,
00327                const typename automaton_traits<T>::htransition_t& e)
00328   {
00329     return op_series_of(s, v.object(), e);
00330   }
00331 
00332   template <class S, class T>
00333   typename Element<S, T>::series_set_elt_value_t
00334   op_series_value_of(const AutomataBase<S>& s,
00335                      const IdentityView<T>& v,
00336                      const typename automaton_traits<T>::htransition_t& e)
00337   {
00338     return op_series_value_of(s, v.object(), e);
00339   }
00340 
00341   template <class S, class T>
00342   typename Element<S, T>::monoid_elt_t
00343   op_word_of(const AutomataBase<S>& s,
00344              const IdentityView<T>& v,
00345              const typename automaton_traits<T>::htransition_t& e)
00346   {
00347     return op_word_of(s, v.object(), e);
00348   }
00349 
00350   template <class S, class T>
00351   typename Element<S, T>::monoid_elt_value_t
00352   op_word_value_of(const AutomataBase<S>& s,
00353                    const IdentityView<T>& v,
00354                    const typename automaton_traits<T>::htransition_t& e)
00355   {
00356     return op_word_value_of(s, v.object(), e);
00357   }
00358 
00359   template <class S, class T>
00360   typename Element<S, T>::letter_t
00361   op_letter_of(const AutomataBase<S>& s,
00362                const IdentityView<T>& v,
00363                const typename automaton_traits<T>::htransition_t& e)
00364   {
00365     return op_letter_of(s, v.object(), e);
00366   }
00367 
00368   template <class S, class T>
00369   bool
00370   op_is_spontaneous(const AutomataBase<S>& s,
00371                     const IdentityView<T>& v,
00372                     const typename automaton_traits<T>::htransition_t& e)
00373   {
00374     return op_is_spontaneous(s, v.object(), e);
00375   }
00376 
00377   // output_return_type = Container
00378   // output_type        = const typename automaton_traits<T>::htransition_t&
00379   // direction          = output
00380 
00381   template <class S, class T,
00382             typename Container>
00383   void op_deltac(const AutomataBase<S>& s,
00384                  const IdentityView<T>& v,
00385                  Container& res, const typename automaton_traits<T>::hstate_t& from, delta_kind::transitions k)
00386   {
00387     op_deltac(s, v.object(), res, from, k);
00388   }
00389 
00390   template <class S, class T,
00391             typename Container, typename L>
00392   void op_deltac(const AutomataBase<S>& s,
00393                  const IdentityView<T>& v,
00394                  Container& res,
00395                  const typename automaton_traits<T>::hstate_t& from,
00396                  const L& query,
00397                  delta_kind::transitions k)
00398   {
00399     op_deltac(s, v.object(), res, from, query, k);
00400   }
00401 
00402   template <class S, class T,
00403             typename Container, typename L>
00404   void op_letter_deltac(const AutomataBase<S>& s,
00405                         const IdentityView<T>& v,
00406                         Container& res,
00407                         const typename automaton_traits<T>::hstate_t& from,
00408                         const L& letter,
00409                         delta_kind::transitions k)
00410   {
00411     op_letter_deltac(s, v.object(), res, from, letter, k);
00412   }
00413 
00414   template <class S, class T, class Container>
00415   void op_spontaneous_deltac(const AutomataBase<S>& s,
00416                              const IdentityView<T>& v,
00417                              Container& res,
00418                              const typename automaton_traits<T>::hstate_t& from,
00419                              delta_kind::transitions k)
00420   {
00421     op_spontaneous_deltac(s, v.object(), res, from, k);
00422   }
00423 
00424   // output_return_type = Container
00425   // output_type        = const typename automaton_traits<T>::hstate_t&
00426   // direction          = output
00427 
00428   template<class S, class T, typename Container>
00429   void op_deltac(const AutomataBase<S>& s,
00430                  const IdentityView<T>& v,
00431                  Container& res, const typename automaton_traits<T>::hstate_t& from, delta_kind::states k)
00432   {
00433     op_deltac(s, v.object(), res, from, k);
00434   }
00435 
00436   template<class S, class T, typename Container, typename L>
00437   void op_deltac(const AutomataBase<S>& s,
00438                  const IdentityView<T>& v,
00439                  Container& res,
00440                  const typename automaton_traits<T>::hstate_t& from,
00441                  const L& query,
00442                  delta_kind::states k)
00443   {
00444     op_deltac(s, v.object(), res, from, k);
00445   }
00446 
00447   template<class S, class T, typename Container, typename L>
00448   void op_letter_deltac(const AutomataBase<S>& s,
00449                         const IdentityView<T>& v,
00450                         Container& res,
00451                         const typename automaton_traits<T>::hstate_t& from,
00452                         const L& letter,
00453                         delta_kind::states k)
00454   {
00455     op_letter_deltac(s, v.object(), res, from, letter, k);
00456   }
00457 
00458   template<class S, class T, typename Container>
00459   void op_spontaneous_deltac(const AutomataBase<S>& s,
00460                              const IdentityView<T>& v,
00461                              Container& res,
00462                              const typename automaton_traits<T>::hstate_t& from,
00463                              delta_kind::states k)
00464   {
00465     op_spontaneous_deltac(s, v.object(), res, from, k);
00466   }
00467 
00468   // output_return_type = Container
00469   // output_type        = const typename automaton_traits<T>::htransition_t&
00470   // direction          = input
00471 
00472   template<class S, class T, typename Container>
00473   void op_rdeltac(const AutomataBase<S>& s, const IdentityView<T>& v,
00474                   Container& res, const typename automaton_traits<T>::hstate_t& from, delta_kind::transitions k)
00475   {
00476     op_rdeltac(s, v.object(), res, from, k);
00477   }
00478 
00479   template<class S, class T, typename Container, typename L>
00480   void op_rdeltac(const AutomataBase<S>& s, const IdentityView<T>& v,
00481                   Container& res,
00482                   const typename automaton_traits<T>::hstate_t& from,
00483                   const L& query,
00484                   delta_kind::transitions k)
00485   {
00486     op_rdeltac(s, v.object(), res, from, query, k);
00487   }
00488 
00489   template<class S, class T, typename Container, typename L>
00490   void op_letter_rdeltac(const AutomataBase<S>& s, const IdentityView<T>& v,
00491                          Container& res,
00492                          const typename automaton_traits<T>::hstate_t& from,
00493                          const L& letter,
00494                          delta_kind::transitions k)
00495   {
00496     op_letter_rdeltac(s, v.object(), res, from, letter, k);
00497   }
00498 
00499   template<class S, class T, typename Container>
00500   void op_spontaneous_rdeltac(const AutomataBase<S>& s,
00501                               const IdentityView<T>& v,
00502                               Container& res,
00503                               const typename automaton_traits<T>::hstate_t& from,
00504                               delta_kind::transitions k)
00505   {
00506     op_spontaneous_rdeltac(s, v.object(), res, from, k);
00507   }
00508 
00509   // output_return_type = Container
00510   // output_type        = const typename automaton_traits<T>::hstate_t&
00511   // direction          = input
00512 
00513   template<class S, class T, typename Container>
00514   void op_rdeltac(const AutomataBase<S>& s, const IdentityView<T>& v,
00515                   Container& res, const typename automaton_traits<T>::hstate_t& from, delta_kind::states k)
00516   {
00517     op_rdeltac(s, v.object(), res, from, k);
00518   }
00519 
00520   template<class S, class T, typename Container, typename L>
00521   void op_rdeltac(const AutomataBase<S>& s, const IdentityView<T>& v,
00522                   Container& res,
00523                   const typename automaton_traits<T>::hstate_t& from,
00524                   const L& query,
00525                   delta_kind::states k)
00526   {
00527     op_rdeltac(s, v.object(), res, from, query, k);
00528   }
00529 
00530   template<class S, class T, typename Container, typename L>
00531   void op_letter_rdeltac(const AutomataBase<S>& s, const IdentityView<T>& v,
00532                          Container& res,
00533                          const typename automaton_traits<T>::hstate_t& from,
00534                          const L& letter,
00535                          delta_kind::states k)
00536   {
00537     op_letter_rdeltac(s, v.object(), res, from, letter, k);
00538   }
00539 
00540   template<class S, class T, typename Container>
00541   void op_spontaneous_rdeltac(const AutomataBase<S>& s,
00542                               const IdentityView<T>& v,
00543                               Container& res,
00544                               const typename automaton_traits<T>::hstate_t& from,
00545                               delta_kind::states k)
00546   {
00547     op_spontaneous_rldeltac(s, v.object(), res, from, k);
00548   }
00549 
00550 } // vcsn
00551 
00552 # undef AutoType
00553 
00554 #endif // ! VCSN_AUTOMATA_IMPLEMENTATION_AUTOMATON_VIEW_HXX