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

- File List
- File Members

# 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   typename automaton_traits<T>::htransition_t                           \
    00029   op_add_letter_transition(const AutomataBase<S>& s,                    \
    00030                            T& v,                                        \
    00031                            const typename automaton_traits<T>::hstate_t& from,\
    00032                            const typename automaton_traits<T>::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                const typename automaton_traits<T>::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              const typename automaton_traits<T>::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
    00095 #define ADAPT_ADD_SERIE_TRANSITION_TO_LETTERS_LABEL(T...)                     \
    00096   typename automaton_traits<T>::htransition_t                                 \
    00097   op_add_series_transition(const AutomataBase<S>& a_set,                      \
    00098                            T& v,                                              \
    00099                            const typename automaton_traits<T>::hstate_t& from,\
    00100                            const typename automaton_traits<T>::hstate_t& to,  \
    00101                            const typename Element<S,T>::series_set_elt_t& s)  \
    00102   {                                                                           \
    00103     assertion(s.supp().size() == 1);                                          \
    00104     typedef typename Element<S, T>::series_set_elt_t::value_t::monoid_elt_value_t\
    00105                                                     monoid_elt_value_t;       \
    00106     typename automaton_traits<T>::htransition_t res;                          \
    00107     monoid_elt_value_t supp = *s.supp().begin();                              \
    00108     for (typename monoid_elt_value_t::const_iterator it = supp.begin();       \
    00109          it != supp.end(); ++it)                                              \
    00110        res = op_add_letter_transition(a_set, v, from, to, *it);               \
    00111     return res;                                                               \
    00112   }
    00113
    00114 #define ADAPT_WORD_OF_TO_LETTERS_LABEL(T...)                      \
    00115   typename Element<AutomataBase<S>, T >::monoid_elt_t             \
    00116   op_word_of(const AutomataBase<S>& a_set,                        \
    00117              const T& v,                                          \
    00118              const typename automaton_traits<T>::htransition_t& e)\
    00119   {                                                               \
    00120     typedef T value_t;                                            \
    00121     typedef typename S::series_set_t series_set_t;                \
    00122     typedef typename series_set_t::monoid_t monoid_t;             \
    00123     typedef typename Element<S, value_t>::monoid_elt_value_t      \
    00124       word_value_t;                                               \
    00125     Element<monoid_t, word_value_t>                               \
    00126       w(a_set.series().monoid());                                 \
    00127     w += op_letter_of(a_set, v, e);                               \
    00128     return w;                                                     \
    00129   }
    00130
    00131 #define ADAPT_SERIE_OF_TO_LETTERS_LABEL(T...)                           \
    00132   typename Element<AutomataBase<S>, T >::series_set_elt_t               \
    00133   op_series_of(const AutomataBase<S>& a_set,                            \
    00134                const T& v,                                              \
    00135                const typename automaton_traits<T>::htransition_t& e)    \
    00136   {                                                                     \
    00137     typedef T value_t;                                                  \
    00138                                                                         \
    00139     typedef typename S::series_set_t series_set_t;                      \
    00140     typedef typename series_set_t::monoid_t monoid_t;                   \
    00141     typedef typename Element<S, value_t>::monoid_elt_value_t            \
    00142       word_value_t;                                                     \
    00143     typedef typename Element<S, value_t>::semiring_elt_value_t          \
    00144       semiring_elt_value_t;                                             \
    00145     typedef typename Element<S, value_t>::series_set_elt_value_t        \
    00146       series_set_elt_value_t;                                           \
    00147     Element<monoid_t, word_value_t> w(a_set.series().monoid());         \
    00148     w = op_letter_of(a_set, v, e);                                      \
    00149     Element<series_set_t, series_set_elt_value_t> s(a_set.series());    \
    00150     s.assoc(w, algebra::identity_as<semiring_elt_value_t>               \
    00151             ::of(a_set.series().semiring()));                           \
    00152     return s;                                                           \
    00153   }
    00154
    00155 } // vcsn
    00156
    00157 # if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
    00158 #  include <vaucanson/automata/implementation/kind_adapter.hxx>
    00159 # endif // VCSN_USE_INTERFACE_ONLY
    00160
    00161 #endif // ! VCSN_AUTOMATA_IMPLEMENTATION_KIND_ADAPTER_HH