Vaucanson: automata_ops.hh Source File

00001 // automata_ops.hh: 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 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_OPS_HH
00018 # define VCSN_AUTOMATA_CONCEPT_AUTOMATA_OPS_HH
00019 
00030 # include <vaucanson/automata/concept/automata_base.hh>
00031 
00032 namespace vcsn {
00033 
00034 #define AutoType(Type)                          \
00035   typename Element<S, T>::Type
00036 
00040 
00041 
00042 
00043   template <class S, class T>
00044   const typename automaton_traits<T>::tag_t&
00045   op_get_tag(const AutomataBase<S>&, const T&);
00046 
00047   template <class S, class T>
00048   typename automaton_traits<T>::tag_t&
00049   op_get_tag(const AutomataBase<S>&, T&);
00050 
00051   template <class S, class T>
00052   const typename automaton_traits<T>::geometry_t&
00053   op_get_geometry(const AutomataBase<S>&, const T&);
00054 
00055   template <class S, class T>
00056   typename automaton_traits<T>::geometry_t&
00057   op_get_geometry(const AutomataBase<S>&, T&);
00058 
00059   template <class S, class T>
00060   bool
00061   op_exists(const AutomataBase<S>& s, const T&);
00062 
00063   template <class S, class T>
00064   typename automaton_traits<T>::states_t
00065   op_states(const AutomataBase<S>&, const T&);
00066 
00067   template <class S, class T>
00068   typename automaton_traits<T>::transitions_t
00069   op_transitions(const AutomataBase<S>&, const T&);
00070 
00071   template <class S, class T>
00072   typename automaton_traits<T>::initial_support_t
00073   op_initial(const AutomataBase<S>&, const T&);
00074 
00075   template <class S, class T>
00076   typename automaton_traits<T>::final_support_t
00077   op_final(const AutomataBase<S>&, const T&);
00078 
00079   template <class S, class T>
00080   void
00081   op_set_initial(const AutomataBase<S>&, T&,
00082                  hstate_t state,
00083                  const AutoType(series_set_elt_t)& s);
00084 
00085   template <class S, class T>
00086   AutoType(series_set_elt_t)
00087   op_get_initial(const AutomataBase<S>&,
00088                  const T&,
00089                  hstate_t state);
00090 
00091   template <class S, class T>
00092   void
00093   op_set_final(const AutomataBase<S>&, T&,
00094                hstate_t state,
00095                const typename Element<S, T>::series_set_elt_t& s);
00096 
00097   template <class S, class T>
00098   typename Element<S, T>::series_set_elt_t
00099   op_get_final(const AutomataBase<S>&,
00100                const T&,
00101                hstate_t state);
00102 
00103   template <class S, class T>
00104   void
00105   op_clear_initial(const AutomataBase<S>&, T&);
00106 
00107   template <class S, class T>
00108   void
00109   op_clear_final(const AutomataBase<S>&, T&);
00110 
00111   template <class S, class T>
00112   hstate_t
00113   op_add_state(const AutomataBase<S>&, T&);
00114 
00115   template <class S, class T>
00116   hstate_t
00117   op_choose_state(const AutomataBase<S>&, T&);
00118 
00119   template <class S, class T>
00120   htransition_t
00121   op_add_transition(const AutomataBase<S>&, T&,
00122                     hstate_t from,
00123                     hstate_t to,
00124                     const typename Element<S, T>::label_t& label);
00125 
00126   template<class S, class T>
00127   htransition_t
00128   op_add_weighted_transition(const AutomataBase<S>&, T&,
00129                              hstate_t from,
00130                              hstate_t to,
00131                              const typename Element<S, T>::semiring_elt_t& w,
00132                              const typename Element<S, T>::monoid_elt_value_t& m);
00133 
00134   template <class S, class T>
00135   htransition_t
00136   op_add_series_transition(const AutomataBase<S>&, T&,
00137                            hstate_t from,
00138                            hstate_t to,
00139                            const typename Element<S, T>::series_set_elt_t&);
00140 
00141   template <class S, class T>
00142   htransition_t
00143   op_add_spontaneous(const AutomataBase<S>&, T&,
00144                      hstate_t from,
00145                      hstate_t to,
00146                      const typename Element<S, T>::semiring_elt_t&);
00147 
00148   template <class S, class T>
00149   htransition_t
00150   op_add_letter_transition(const AutomataBase<S>&, T&,
00151                            hstate_t from,
00152                            hstate_t to,
00153                            const typename Element<S, T>::letter_t&);
00154 
00155   template <class S, class T>
00156   void
00157   op_update(const AutomataBase<S>&, T&,
00158             htransition_t,
00159             const AutoType(label_t)& l);
00160 
00161   template <class S, class T>
00162   void
00163   op_del_state(const AutomataBase<S>&, T&,
00164                hstate_t);
00165 
00166   template <class S, class T>
00167   void
00168   op_del_transition(const AutomataBase<S>&, T&,
00169                     htransition_t);
00170 
00171   template <class S, class T>
00172   bool
00173   op_has_state(const AutomataBase<S>&, const T&,
00174                hstate_t);
00175 
00176   template <class S, class T>
00177   bool
00178   op_has_transition(const AutomataBase<S>&, const T&,
00179                     htransition_t);
00180 
00181   template <class S, class T>
00182   hstate_t
00183   op_src_of(const AutomataBase<S>&, const T&,
00184             htransition_t);
00185 
00186   template <class S, class T>
00187   hstate_t
00188   op_dst_of(const AutomataBase<S>&, const T&,
00189             htransition_t);
00190 
00191   template <class S, class T>
00192   typename Element<S, T>::label_t
00193   op_label_of(const AutomataBase<S>&, const T&,
00194               htransition_t);
00195 
00196   template <class S, class T>
00197   const typename Element<S, T>::series_set_elt_t
00198   op_series_of(const AutomataBase<S>&, const T&,
00199                htransition_t);
00200 
00201   template <class S, class T>
00202   typename Element<S, T>::series_set_elt_value_t
00203   op_series_value_of(const AutomataBase<S>&, const T&,
00204                      htransition_t);
00205 
00206 
00207   template <class S, class T>
00208   typename Element<S, T>::monoid_elt_t
00209   op_word_of(const AutomataBase<S>&, const T&,
00210              htransition_t);
00211 
00212   template <class S, class T>
00213   typename Element<S, T>::semiring_elt_t
00214   op_weight_of(const AutomataBase<S>&, const T&,
00215                htransition_t);
00216 
00217   template <class S, class T>
00218   typename Element<S, T>::monoid_elt_value_t
00219   op_word_value_of(const AutomataBase<S>&, const T&,
00220                    htransition_t);
00221 
00222   template <class S, class T>
00223   typename Element<S, T>::letter_t
00224   op_letter_of(const AutomataBase<S>&, const T&,
00225                htransition_t);
00226 
00227   template <class S, class T>
00228   bool
00229   op_is_spontaneous(const AutomataBase<S>&, const T&,
00230                     htransition_t);
00231 
00233 
00234   // output_return_type = OutputIterator
00235   // output_type        = htransition_t
00236   // direction          = output
00237 
00239   template <class S, class T,
00240             typename OutputIterator>
00241   void op_delta(const AutomataBase<S>&, const T&,
00242                 OutputIterator res,
00243                 hstate_t from,
00244                 delta_kind::transitions k);
00245 
00252   template <class S, class T,
00253             typename OutputIterator, typename L>
00254   void op_delta(const AutomataBase<S>&, const T&,
00255                 OutputIterator res,
00256                 hstate_t from,
00257                 const L& query,
00258                 delta_kind::transitions k);
00259 
00266   template <class S, class T,
00267             typename OutputIterator, typename L>
00268   void op_letter_delta(const AutomataBase<S>&, const T&,
00269                        OutputIterator res,
00270                        hstate_t from,
00271                        const L& letter,
00272                        delta_kind::transitions k);
00273 
00275   template <class S, class T,
00276             typename OutputIterator>
00277   void op_spontaneous_delta(const AutomataBase<S>&, const T&,
00278                             OutputIterator res,
00279                             hstate_t from,
00280                             delta_kind::transitions k);
00281 
00282   // output_return_type = Container
00283   // output_type        = htransition_t
00284   // direction          = output
00285 
00287   template <class S, class T,
00288             typename Container>
00289   void op_deltac(const AutomataBase<S>&, const T&,
00290                  Container& res, hstate_t from, delta_kind::transitions k);
00291 
00298   template <class S, class T,
00299             typename Container, typename L>
00300   void op_deltac(const AutomataBase<S>&, const T&,
00301                  Container& res,
00302                  hstate_t from,
00303                  const L& query,
00304                  delta_kind::transitions k);
00305 
00312   template <class S, class T,
00313             typename Container, typename L>
00314   void op_letter_deltac(const AutomataBase<S>&, const T&,
00315                         Container& res,
00316                         hstate_t from,
00317                         const L& letter,
00318                         delta_kind::transitions k);
00319 
00321   template <class S, class T, class Container>
00322   void op_spontaneous_deltac(const AutomataBase<S>&, const T&,
00323                              Container& res,
00324                              hstate_t from,
00325                              delta_kind::transitions k);
00326 
00327   // output_return_type = OutputIterator
00328   // output_type        = hstate_t
00329   // direction          = output
00330 
00332   template<class S, class T, typename OutputIterator>
00333   void op_delta(const AutomataBase<S>&, const T&,
00334                 OutputIterator res,
00335                 hstate_t from,
00336                 delta_kind::states k);
00337 
00344   template<class S, class T, typename OutputIterator, typename L>
00345   void op_delta(const AutomataBase<S>&, const T&,
00346                 OutputIterator res,
00347                 hstate_t from,
00348                 const L& query,
00349                 delta_kind::states k);
00350 
00357   template<class S, class T, typename OutputIterator, typename L>
00358   void op_letter_delta(const AutomataBase<S>&, const T&,
00359                        OutputIterator res,
00360                        hstate_t from,
00361                        const L& letter,
00362                        delta_kind::states k);
00363 
00365   template<class S, class T, typename OutputIterator>
00366   void op_spontaneous_delta(const AutomataBase<S>&, const T&,
00367                             OutputIterator res,
00368                             hstate_t from,
00369                             delta_kind::states k);
00370 
00371   // output_return_type = Container
00372   // output_type        = hstate_t
00373   // direction          = output
00374 
00376   template<class S, class T, typename Container>
00377   void op_deltac(const AutomataBase<S>&, const T&,
00378                  Container& res, hstate_t from, delta_kind::states k);
00379 
00386   template<class S, class T, typename Container, typename L>
00387   void op_deltac(const AutomataBase<S>&, const T&,
00388                  Container& res,
00389                  hstate_t from,
00390                  const L& query,
00391                  delta_kind::states k);
00392 
00399   template<class S, class T, typename Container, typename L>
00400   void op_letter_deltac(const AutomataBase<S>&, const T&,
00401                         Container& res,
00402                         hstate_t from,
00403                         const L& letter,
00404                         delta_kind::states k);
00405 
00407   template<class S, class T, typename Container>
00408   void op_spontaneous_deltac(const AutomataBase<S>&, const T&,
00409                              Container& res,
00410                              hstate_t from,
00411                              delta_kind::states k);
00412 
00413   // output_return_type = OutputIterator
00414   // output_type        = htransition_t
00415   // direction          = input
00416 
00418   template<class S, class T, typename OutputIterator>
00419   void op_rdelta(const AutomataBase<S>&, const T&,
00420                  OutputIterator res,
00421                  hstate_t from,
00422                  delta_kind::transitions k);
00423 
00430   template<class S, class T, typename OutputIterator, typename L>
00431   void op_rdelta(const AutomataBase<S>&, const T&,
00432                  OutputIterator res,
00433                  hstate_t from,
00434                  const L& query,
00435                  delta_kind::transitions k);
00436 
00443   template<class S, class T, typename OutputIterator, typename L>
00444   void op_letter_rdelta(const AutomataBase<S>&, const T&,
00445                         OutputIterator res,
00446                         hstate_t from,
00447                         const L& letter,
00448                         delta_kind::transitions k);
00449 
00451   template<class S, class T, typename OutputIterator>
00452   void op_spontaneous_rdelta(const AutomataBase<S>&, const T&,
00453                              OutputIterator res,
00454                              hstate_t from,
00455                              delta_kind::transitions k);
00456 
00457   // output_return_type = Container
00458   // output_type        = htransition_t
00459   // direction          = input
00460 
00462   template<class S, class T, typename Container>
00463   void op_rdeltac(const AutomataBase<S>&, const T&,
00464                   Container& res, hstate_t from, delta_kind::transitions k);
00465 
00472   template<class S, class T, typename Container, typename L>
00473   void op_rdeltac(const AutomataBase<S>&, const T&,
00474                   Container& res,
00475                   hstate_t from,
00476                   const L& query,
00477                   delta_kind::transitions k);
00478 
00485   template<class S, class T, typename Container, typename L>
00486   void op_letter_rdeltac(const AutomataBase<S>&, const T&,
00487                          Container& res,
00488                          hstate_t from,
00489                          const L& letter,
00490                          delta_kind::transitions k);
00491 
00493   template<class S, class T, typename Container>
00494   void op_spontaneous_rdeltac(const AutomataBase<S>&, const T&,
00495                               Container& res,
00496                               hstate_t from,
00497                               delta_kind::transitions k);
00498 
00499   // output_return_type = OutputIterator
00500   // output_type        = hstate_t
00501   // direction          = input
00502 
00504   template<class S, class T, typename OutputIterator>
00505   void op_rdelta(const AutomataBase<S>&, const T&,
00506                  OutputIterator res,
00507                  hstate_t from,
00508                  delta_kind::states k);
00509 
00516   template<class S, class T, typename OutputIterator, typename L>
00517   void op_rdelta(const AutomataBase<S>&, const T&,
00518                  OutputIterator res,
00519                  hstate_t from,
00520                  const L& query,
00521                  delta_kind::states k);
00522 
00529   template<class S, class T, typename OutputIterator, typename L>
00530   void op_letter_rdelta(const AutomataBase<S>&, const T&,
00531                         OutputIterator res,
00532                         hstate_t from,
00533                         const L& letter,
00534                         delta_kind::states k);
00535 
00537   template<class S, class T, typename OutputIterator>
00538   void op_spontaneous_rdelta(const AutomataBase<S>&, const T&,
00539                              OutputIterator res,
00540                              hstate_t from,
00541                              delta_kind::states k);
00542 
00543   // output_return_type = Container
00544   // output_type        = hstate_t
00545   // direction          = input
00546 
00548   template<class S, class T, typename Container>
00549   void op_rdeltac(const AutomataBase<S>&, const T&,
00550                   Container& res, hstate_t from, delta_kind::states k);
00551 
00558   template<class S, class T, typename Container, typename L>
00559   void op_rdeltac(const AutomataBase<S>&, const T&,
00560                   Container& res,
00561                   hstate_t from,
00562                   const L& query,
00563                   delta_kind::states k);
00564 
00571   template<class S, class T, typename Container, typename L>
00572   void op_letter_rdeltac(const AutomataBase<S>&, const T&,
00573                          Container& res,
00574                          hstate_t from,
00575                          const L& letter,
00576                          delta_kind::states k);
00577 
00579   template<class S, class T, typename Container>
00580   void op_spontaneous_rdeltac(const AutomataBase<S>&, const T&,
00581                               Container& res,
00582                               hstate_t from,
00583                               delta_kind::states k);
00584 
00588 } // vcsn
00589 
00590 
00591 # ifndef VCSN_USE_INTERFACE_ONLY
00592 #  include <vaucanson/automata/concept/automata_ops.hxx>
00593 # endif // VCSN_USE_INTERFACE_ONLY
00594 
00595 
00596 #endif // ! VCSN_AUTOMATA_CONCEPT_AUTOMATA_OPS_HH