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

# kind_adapter.hh

    00001 // kind_adapter.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_IMPLEMENTATION_KIND_ADAPTER_HH
    00018 # define VCSN_AUTOMATA_IMPLEMENTATION_KIND_ADAPTER_HH
    00019
    00020 # include <vaucanson/automata/concept/automata_kind.hh>
    00021
    00022 namespace vcsn {
    00023
    00026
    00027 #define ADAPT_ADD_LETTER_TRANSITION_TO_SERIES_LABEL(T...)               \
    00028   htransition_t                                                         \
    00029   op_add_letter_transition(const AutomataBase<S>& s,                    \
    00030                            T& v,                                        \
    00031                            hstate_t from,                               \
    00032                            hstate_t to,                                 \
    00033                            const typename Element<S, T >::letter_t & l) \
    00034   {                                                                     \
    00035     typedef typename S::series_set_t            series_set_t;           \
    00036     typedef typename series_set_t::monoid_t     monoid_t;               \
    00037     typedef typename series_set_t::semiring_t   semiring_t;             \
    00038     typedef typename Element<S, T >::monoid_elt_value_t                 \
    00039       monoid_elt_value_t;                                               \
    00040     typedef typename Element<S, T >::semiring_elt_value_t               \
    00041       semiring_elt_value_t;                                             \
    00042     typedef typename Element<S, T >::series_set_elt_value_t             \
    00043       series_set_elt_value_t;                                           \
    00044                                                                         \
    00045     Element<series_set_t, series_set_elt_value_t> label (s.series());   \
    00046                                                                         \
    00047     Element<monoid_t, monoid_elt_value_t> word (s.series().monoid(), l); \
    00048     label.assoc(word,                                                   \
    00049                 s.series().semiring().identity(SELECT(semiring_elt_value_t))); \
    00050                                                                         \
    00051     return op_add_transition(s, v, from, to, label.value());            \
    00052   }
    00053
    00054 #define ADAPT_LETTER_OF_TO_SERIES_LABEL(T...)                           \
    00055   typename Element<AutomataBase<S>, T >::letter_t                       \
    00056   op_letter_of(const AutomataBase<S>& s,                                \
    00057                const T& v,                                              \
    00058                htransition_t e)                                         \
    00059   {                                                                     \
    00060     typedef typename S::series_set_t series_set_t;                      \
    00061     typedef typename series_set_t::monoid_t monoid_t;                   \
    00062     typedef typename Element<S, T >::monoid_elt_value_t                 \
    00063       word_value_t;                                                     \
    00064     typedef typename Element<S, T >::series_set_elt_value_t             \
    00065       series_set_elt_value_t;                                           \
    00066                                                                         \
    00067     Element<series_set_t, series_set_elt_value_t> sl = op_series_of(s, v, e); \
    00068     precondition(sl.supp().size() == 1);                                \
    00069     Element<monoid_t, word_value_t> w = sl.choose_from_supp();          \
    00070     precondition(w.length() == 1);                                      \
    00071     return *w.begin();                                                  \
    00072   }
    00073
    00074 #define ADAPT_WORD_OF_TO_SERIES_LABEL(T...)                             \
    00075   typename Element<AutomataBase<S>, T >::monoid_elt_t                   \
    00076   op_word_of(const AutomataBase<S>& s,                                  \
    00077              const T& v,                                                \
    00078              htransition_t e)                                           \
    00079   {                                                                     \
    00080     typedef typename S::series_set_t series_set_t;                      \
    00081     typedef typename series_set_t::monoid_t monoid_t;                   \
    00082     typedef typename Element<S, T >::monoid_elt_value_t                 \
    00083       word_value_t;                                                     \
    00084     typedef typename Element<S, T >::series_set_elt_value_t             \
    00085       series_set_elt_value_t;                                           \
    00086                                                                         \
    00087     Element<series_set_t, series_set_elt_value_t> sl = op_series_of(s, v, e); \
    00088     precondition(sl.supp().size() == 1);                                \
    00089     Element<monoid_t, word_value_t> w = sl.choose_from_supp();          \
    00090     return w;                                                           \
    00091   }
    00092
    00093 #define ADAPT_ADD_SERIE_TRANSITION_TO_LETTERS_LABEL(T...)               \
    00094   htransition_t                                                         \
    00095   op_add_series_transition(const AutomataBase<S>& a_set,                \
    00096                            T& v,                                        \
    00097                            hstate_t from,                               \
    00098                            hstate_t to,                                 \
    00099                            const typename Element<S,T >::series_set_elt_t& s) \
    00100   {                                                                     \
    00101     assertion(s.supp().size() == 1);                                    \
    00102     return op_add_letter_transition(a_set, v, from, to, *s.supp().begin()); \
    00103   }
    00104
    00105 #define ADAPT_WORD_OF_TO_LETTERS_LABEL(T...)                    \
    00106   typename Element<AutomataBase<S>, T >::monoid_elt_t           \
    00107   op_word_of(const AutomataBase<S>& a_set,                      \
    00108              const T& v,                                        \
    00109              htransition_t e)                                   \
    00110   {                                                             \
    00111     typedef T value_t;                                          \
    00112     typedef typename S::series_set_t series_set_t;              \
    00113     typedef typename series_set_t::monoid_t monoid_t;           \
    00114     typedef typename Element<S, value_t>::monoid_elt_value_t    \
    00115       word_value_t;                                             \
    00116     Element<monoid_t, word_value_t>                             \
    00117       w(a_set.series().monoid());                               \
    00118     w += op_letter_of(a_set, v, e);                             \
    00119     return w;                                                   \
    00120   }
    00121
    00122 #define ADAPT_SERIE_OF_TO_LETTERS_LABEL(T...)                           \
    00123   typename Element<AutomataBase<S>, T >::series_set_elt_t               \
    00124   op_series_of(const AutomataBase<S>& a_set,                            \
    00125                const T& v,                                              \
    00126                htransition_t e)                                         \
    00127   {                                                                     \
    00128     typedef T value_t;                                                  \
    00129                                                                         \
    00130     typedef typename S::series_set_t series_set_t;                      \
    00131     typedef typename series_set_t::monoid_t monoid_t;                   \
    00132     typedef typename Element<S, value_t>::monoid_elt_value_t            \
    00133       word_value_t;                                                     \
    00134     typedef typename Element<S, value_t>::semiring_elt_value_t          \
    00135       semiring_elt_value_t;                                             \
    00136     typedef typename Element<S, value_t>::series_set_elt_value_t        \
    00137       series_set_elt_value_t;                                           \
    00138     Element<monoid_t, word_value_t> w(a_set.series().monoid());         \
    00139     w = op_letter_of(a_set, v, e);                                      \
    00140     Element<series_set_t, series_set_elt_value_t> s(a_set.series());    \
    00141     s.assoc(w, algebra::identity_as<semiring_elt_value_t>               \
    00142             ::of(a_set.series().semiring()));                           \
    00143     return s;                                                           \
    00144   }
    00145
    00146 } // vcsn
    00147
    00148 # if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
    00149 #  include <vaucanson/automata/implementation/kind_adapter.hxx>
    00150 # endif // VCSN_USE_INTERFACE_ONLY
    00151
    00152 #endif // ! VCSN_AUTOMATA_IMPLEMENTATION_KIND_ADAPTER_HH