transducer_base.hh

// transducer_base.hh: this file is part of the Vaucanson project.
//
// Vaucanson, a generic library for finite state machines.
//
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The
// Vaucanson Group.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// The complete GNU General Public Licence Notice can be found as the
// `COPYING' file in the root directory.
//
// The Vaucanson Group consists of people listed in the `AUTHORS' file.
//
#ifndef VCSN_AUTOMATA_CONCEPT_TRANSDUCER_BASE_HH
# define VCSN_AUTOMATA_CONCEPT_TRANSDUCER_BASE_HH

# include <iterator>
# include <vaucanson/design_pattern/design_pattern.hh>
# include <vaucanson/design_pattern/predecls.hh>
# include <vaucanson/automata/concept/automata_base.hh>
# include <vaucanson/misc/usual_macros.hh>

namespace vcsn {
    
  /*---------------------.
  | TransducerBase<Self> |
  `----------------------*/
  template <typename Self>
  struct TransducerBase
    : AutomataBase<Self>
  {
    public:
      typedef typename virtual_types<Self>::series_set_t  series_set_t;

    protected:
      TransducerBase();

      TransducerBase(const TransducerBase& other);
  };

  template <typename T>
  struct transducer_traits
  {
      typedef undefined_type input_monoid_elt_value_t;
      typedef undefined_type output_monoid_elt_value_t;
  };

  template <typename T>
  struct extension_traits
  {
      typedef undefined_type ret;
  };

  template <class T>
  struct input_projection_traits
  {
      typedef undefined_type    ret;
  };

  template <class T>
  struct fmp_input_projection_traits
  {
      typedef undefined_type    ret;
  };

  // FIXME: the semantic should be defined more precisely.
  // What is the output "on a graph" (it is well defined with
  // transducers)
  template <class T>
  struct output_projection_traits
  {
    typedef undefined_type      ret;
  };

  template <class T>
  struct fmp_output_projection_traits
  {
    typedef undefined_type      ret;
  };

  /*-----------------------------------.
  | virtual_types<AutomataBase<Self> > |
  `-----------------------------------*/
  template <class S>
  struct virtual_types<TransducerBase<S> >
    : virtual_types<AutomataBase<S> >
  { };

  /*------------------------------------.
  | dynamic_traits<AutomataBase<Self> > |
  `------------------------------------*/
  template <class S>
  struct dynamic_traits<TransducerBase<S> >
    : dynamic_traits<AutomataBase<S> >
  { };

  /*-------------------------------------.
  | MetaElement<TransducerBase<Self>, T> |
  `-------------------------------------*/
  template <typename Self, typename T>
  struct MetaElement<TransducerBase<Self>, T>
    : MetaElement<AutomataBase<Self>, T>
  {
      typedef MetaElement<TransducerBase<Self>, T> self_t;

      typedef MetaElement<AutomataBase<Self>, T> super_t;

      typedef MetaElement<AutomataBase<Self>, T> automaton_t;

      IMPORT_TYPEDEF_(automaton_t, series_set_t);

      IMPORT_TYPEDEF_(automaton_t, series_set_elt_value_t);

      IMPORT_TYPEDEF_(automaton_t, series_set_elt_t);

      IMPORT_TYPEDEF_(automaton_t, monoid_t);

      IMPORT_TYPEDEF_(automaton_t, monoid_elt_t);

      IMPORT_TYPEDEF_(automaton_t, monoid_elt_value_t);

      IMPORT_TYPEDEF_(automaton_t, letter_t);

      IMPORT_TYPEDEF_(automaton_t, semiring_t);

      IMPORT_TYPEDEF_(automaton_t, semiring_elt_t);

      IMPORT_TYPEDEF_(automaton_t, semiring_elt_value_t);

      IMPORT_TYPEDEF_(automaton_t, tag_t);

      IMPORT_TYPEDEF_(automaton_t, label_t);

      IMPORT_TYPEDEF_(automaton_t, states_t);

      IMPORT_TYPEDEF_(automaton_t, state_iterator);

      IMPORT_TYPEDEF_(automaton_t, transitions_t);

      IMPORT_TYPEDEF_(automaton_t, transition_iterator);

      IMPORT_TYPEDEF_(automaton_t, initial_support_t);

      IMPORT_TYPEDEF_(automaton_t, initial_iterator);

      IMPORT_TYPEDEF_(automaton_t, final_support_t);

      IMPORT_TYPEDEF_(automaton_t, final_iterator);

      typedef typename super_t::semiring_elt_t output_series_set_elt_t;

      typedef typename algebra::series_traits<semiring_elt_value_t>::monoid_elt_value_t
      output_monoid_elt_value_t;

      typedef typename semiring_t::monoid_t     output_monoid_t;

      typedef Element<output_monoid_t, output_monoid_elt_value_t>
      output_monoid_elt_t;

      typedef typename output_monoid_t::letter_t output_letter_t;

      typedef typename super_t::monoid_elt_value_t input_monoid_elt_value_t;

      typedef typename super_t::monoid_t                input_monoid_t;

      typedef Element<input_monoid_t, input_monoid_elt_value_t>
      input_monoid_elt_t;

      typedef typename input_monoid_t::letter_t input_letter_t;

      typedef typename algebra::series_traits<semiring_elt_value_t>::semiring_elt_value_t
      output_semiring_elt_value_t;

      typedef typename semiring_t::semiring_t   output_semiring_t;

      typedef Element<output_semiring_t, output_semiring_elt_value_t>
      output_semiring_elt_t;

      input_monoid_elt_t input_of(typename automaton_traits<T>::htransition_t) const;

      output_series_set_elt_t output_of(typename automaton_traits<T>::htransition_t) const;

      template <typename U, typename V>
      typename automaton_traits<T>::htransition_t
      add_io_transition(typename automaton_traits<T>::hstate_t, typename automaton_traits<T>::hstate_t,
                        const U&,
                        const V&,
                        output_semiring_elt_t = output_semiring_elt_t());

      template <typename U>
      typename automaton_traits<T>::htransition_t
      add_o_transition(typename automaton_traits<T>::hstate_t, typename automaton_traits<T>::hstate_t,
                       const U&,
                       output_semiring_elt_t = output_semiring_elt_t());

      template <typename U>
      typename automaton_traits<T>::htransition_t
      add_i_transition(typename automaton_traits<T>::hstate_t, typename automaton_traits<T>::hstate_t,
                       const U&,
                       output_semiring_elt_t = output_semiring_elt_t());

      template <typename U>
      void set_o_final(typename automaton_traits<T>::hstate_t, const U&);

      template <typename U>
      void set_o_initial(typename automaton_traits<T>::hstate_t, const U&);

    protected:
      MetaElement();
      MetaElement(const MetaElement& other);
  };


} // vcsn


# if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
#  include <vaucanson/automata/concept/transducer_base.hxx>
# endif // VCSN_USE_INTERFACE_ONLY


#endif // ! VCSN_AUTOMATA_CONCEPT_TRANSDUCER_BASE_HH

---