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

# kinds.hh

    00001 // kinds.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, 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_KINDS_HH
    00018 # define VCSN_AUTOMATA_CONCEPT_KINDS_HH
    00019
    00020 # include <vaucanson/config/system.hh>
    00021 # include <iterator>
    00022 # include <vaucanson/misc/contract.hh>
    00023 # include <algorithm>
    00024
    00025 # include <vaucanson/algebra/concept/series_base.hh>
    00026 # include <vaucanson/design_pattern/design_pattern.hh>
    00027 # include <vaucanson/automata/concept/handlers.hh>
    00028
    00029 namespace vcsn {
    00030
    00031   template <
    00032     typename Kind,
    00033     typename Self,
    00034     typename Series,
    00035     typename SeriesT,
    00036     typename LabelT
    00037     >
    00038   class AutoKind {};
    00039
    00040   namespace delta_kind {
    00041
    00042     struct transitions
    00043     {};
    00044
    00045     struct states
    00046     {};
    00047
    00048   } // delta_kind
    00049
    00050
    00051   struct labels_are_series
    00052   {};
    00053
    00054   template <
    00055     typename Series,
    00056     typename MonoidElt,
    00057     typename SemiringElt,
    00058     typename L
    00059     >
    00060   struct ls_delta_letter_query
    00061   {
    00062       ls_delta_letter_query(const Series& s, const L& l);
    00063
    00064       template<typename Label>
    00065       bool operator()(const Label& label) const;
    00066
    00067     protected:
    00068       SetSlot<Series>                   s_;
    00069       typename MonoidElt::value_t               l_;
    00070   };
    00071
    00072   /*--------------------------------.
    00073   | AutoKind<labels_are_series ...> |
    00074   `--------------------------------*/
    00076
    00082   template <
    00083     typename Self,
    00084     typename Series,
    00085     typename SeriesT,
    00086     typename LabelT
    00087     >
    00088   class AutoKind<labels_are_series, Self, Series, SeriesT, LabelT>
    00089   {
    00090     protected:
    00091       typedef Element<Series, SeriesT>                  series_set_elt_t;
    00092       typedef typename Series::monoid_t                 monoid_t;
    00093       typedef typename series_set_elt_t::monoid_elt_t           monoid_elt_t;
    00094       typedef typename Series::semiring_t                       semiring_t;
    00095       typedef typename series_set_elt_t::semiring_elt_t         semiring_elt_t;
    00096
    00097     public:
    00098
    00099       series_set_elt_t series_of(htransition_t e) const;
    00100
    00101       const SeriesT& series_value_of(htransition_t e) const;
    00102
    00103       bool is_spontaneous(htransition_t e) const;
    00104
    00105       template<typename L>
    00106       L letter_of(SELECTOR(L), htransition_t e) const;
    00107
    00108       monoid_elt_t word_of(htransition_t e) const;
    00109
    00110       const typename monoid_elt_t::value_t& word_value_of(htransition_t e) const;
    00111
    00112       template<typename S>
    00113       htransition_t add_series_transition(hstate_t from, hstate_t to,
    00114                                           const S& e);
    00115
    00116       htransition_t add_spontaneous(hstate_t from, hstate_t to);
    00117
    00118       template<typename L>
    00119       htransition_t add_letter_transition(hstate_t from, hstate_t to,
    00120                                           const L& l);
    00121
    00122       template <typename OutputIterator, typename L>
    00123       void letter_delta(OutputIterator  res,
    00124                         hstate_t                from,
    00125                         const L&                l,
    00126                         delta_kind::transitions k = delta_kind::transitions()) const;
    00127
    00128       template <typename Container, typename L>
    00129       void letter_deltac(Container&      dst,
    00130                          hstate_t                from,
    00131                          const L&                l,
    00132                          delta_kind::transitions k = delta_kind::transitions()) const;
    00133
    00134       template <typename OutputIterator, typename L>
    00135       void letter_rdelta(OutputIterator res,
    00136                          hstate_t               from,
    00137                          const L&               l,
    00138                          delta_kind::transitions k = delta_kind::transitions()) const;
    00139
    00140       template <typename Container, typename L>
    00141       void letter_rdeltac(Container&     dst,
    00142                           hstate_t               from,
    00143                           const L&               l,
    00144                           delta_kind::transitions k = delta_kind::transitions()) const;
    00145
    00146       template <typename OutputIterator, typename L>
    00147       void letter_delta(OutputIterator   res,
    00148                         hstate_t                 from,
    00149                         const L&                 l,
    00150                         delta_kind::states k) const;
    00151
    00152       template <typename Container, typename L>
    00153       void letter_deltac(Container&       dst,
    00154                          hstate_t                 from,
    00155                          const L&                 l,
    00156                          delta_kind::states k) const;
    00157
    00158       template <typename OutputIterator, typename L>
    00159       void letter_rdelta(OutputIterator   res,
    00160                          hstate_t                 from,
    00161                          const L&                 l,
    00162                          delta_kind::states k) const;
    00163
    00164       template <typename Container, typename L>
    00165       void letter_rdeltac(Container&       dst,
    00166                           hstate_t         from,
    00167                           const L&         l,
    00168                           delta_kind::states k) const;
    00169
    00170     protected:
    00171       Self&       auto_self();
    00172       const Self& auto_self() const;
    00173   };
    00174
    00175
    00176   struct labels_are_couples
    00177   {};
    00178
    00179   template<typename Monoid, typename L>
    00180   struct lc_delta_letter_query
    00181   {
    00182       lc_delta_letter_query(const Monoid& m, const L& l);
    00183
    00184       template<typename Label>
    00185       bool operator()(const Label& label) const;
    00186
    00187     protected:
    00188       SetSlot<Monoid>           m_;
    00189       L                         l_;
    00190   };
    00191
    00192   template<typename Self, typename Series, typename SeriesT, typename LabelT>
    00193   class AutoKind<labels_are_couples, Self, Series, SeriesT, LabelT>
    00194   {
    00195     protected:
    00196       typedef Element<Series, SeriesT>                  series_set_elt_t;
    00197       typedef typename Series::monoid_t                 monoid_t;
    00198       typedef typename series_set_elt_t::monoid_elt_t           monoid_elt_t;
    00199       typedef typename Series::semiring_t                       semiring_t;
    00200       typedef typename series_set_elt_t::semiring_elt_t         semiring_elt_t;
    00201
    00202     public:
    00203
    00204       series_set_elt_t  series_of(htransition_t e) const;
    00205
    00206       const SeriesT series_value_of(htransition_t e) const;
    00207
    00208       bool is_spontaneous(htransition_t e) const;
    00209
    00210       template<typename L>
    00211       L letter_of(SELECTOR(L), htransition_t e) const;
    00212
    00213       monoid_elt_t word_of(htransition_t e) const;
    00214
    00215       const typename monoid_elt_t::value_t& word_value_of(htransition_t e) const;
    00216
    00217       template<typename S>
    00218       htransition_t add_series_transition(hstate_t from, hstate_t to,
    00219                                           const S& e);
    00220
    00221       htransition_t add_spontaneous(hstate_t from, hstate_t to);
    00222
    00223       template<typename L>
    00224       htransition_t add_letter_transition(hstate_t from, hstate_t to,
    00225                                           const L& l);
    00226
    00227       template <typename OutputIterator, typename L>
    00228       void letter_delta(OutputIterator  res,
    00229                         hstate_t                from,
    00230                         const L&                l,
    00231                         delta_kind::transitions k = delta_kind::transitions()) const;
    00232
    00233       template <typename Container, typename L>
    00234       void letter_deltac(Container&      dst,
    00235                          hstate_t                from,
    00236                          const L&                l,
    00237                          delta_kind::transitions k = delta_kind::transitions()) const;
    00238
    00239       template <typename OutputIterator, typename L>
    00240       void letter_rdelta(OutputIterator res,
    00241                          hstate_t               from,
    00242                          const L&               l,
    00243                          delta_kind::transitions k = delta_kind::transitions()) const;
    00244
    00245       template <typename Container, typename L>
    00246       void letter_rdeltac(Container&     dst,
    00247                           hstate_t               from,
    00248                           const L&               l,
    00249                           delta_kind::transitions k = delta_kind::transitions()) const;
    00250
    00251       template <typename OutputIterator, typename L>
    00252       void letter_delta(OutputIterator   res,
    00253                         hstate_t                 from,
    00254                         const L&                 l,
    00255                         delta_kind::states k) const;
    00256
    00257       template <typename Container, typename L>
    00258       void letter_deltac(Container&       dst,
    00259                          hstate_t                 from,
    00260                          const L&                 l,
    00261                          delta_kind::states k) const;
    00262
    00263       template <typename OutputIterator, typename L>
    00264       void letter_rdelta(OutputIterator   res,
    00265                          hstate_t                 from,
    00266                          const L&                 l,
    00267                          delta_kind::states k) const;
    00268
    00269       template <typename Container, typename L>
    00270       void letter_rdeltac(Container&       dst,
    00271                           hstate_t         from,
    00272                           const L&         l,
    00273                           delta_kind::states k) const;
    00274
    00275     protected:
    00276       Self&       auto_self();
    00277       const Self& auto_self() const;
    00278   };
    00279
    00280 }
    00281
    00282
    00283 # if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
    00284 # include <vaucanson/automata/concept/kinds.hxx>
    00285 #endif // VCSN_USE_INTERFACE_ONLY
    00286
    00287
    00288 #endif // ! VCSN_AUTOMATA_CONCEPT_KINDS_HH