automata_base.hh

// automata_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 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_AUTOMATA_BASE_HH
# define VCSN_AUTOMATA_CONCEPT_AUTOMATA_BASE_HH

# include <iterator>
# include <vaucanson/design_pattern/design_pattern.hh>
# include <vaucanson/automata/concept/handlers.hh>
# include <vaucanson/automata/concept/delta_kind.hh>
# include <vaucanson/algebra/concept/series_base.hh>

namespace vcsn {
    
  /*-------------------.
  | AutomataBase<Self> |
  `-------------------*/

  template <typename Self>
  struct AutomataBase
    : Structure<Self>
  {
    public:
      typedef typename virtual_types<Self>::series_set_t  series_set_t;

    protected:
      AutomataBase();

      AutomataBase(const AutomataBase& other);

    public:
      const series_set_t& series() const;
  };

  // traits for automaton implementation.
  template <typename T>
  struct automaton_traits {
      typedef undefined_type label_t;
      typedef undefined_type series_set_elt_value_t;
      typedef undefined_type word_value_t;
      typedef undefined_type semiring_elt_value_t;
      typedef undefined_type letter_t;
      typedef undefined_type tag_t;
      typedef undefined_type states_t;
      typedef undefined_type state_data_t;
      typedef undefined_type state_iterator;
      typedef undefined_type transitions_t;
      typedef undefined_type transition_data_t;
      typedef undefined_type transition_iterator;
      typedef undefined_type initial_t;
      typedef undefined_type initial_iterator;
      typedef undefined_type initial_support_t;
      typedef undefined_type final_t;
      typedef undefined_type final_iterator;
      typedef undefined_type final_support_t;
      typedef undefined_type geometry_t;
  };

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

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

  /*-----------------------------------.
  | MetaElement<AutomataBase<Self>, T> |
  `-----------------------------------*/

  template <typename Self, typename T>
  struct MetaElement<AutomataBase<Self>, T>
    : MetaElement<Structure<Self>, T>
  {
      typedef MetaElement<AutomataBase<Self>, T>        self_t;

      typedef typename AutomataBase<Self>::series_set_t series_set_t;

      typedef typename automaton_traits<T>::series_set_elt_value_t
      series_set_elt_value_t;

      typedef Element<series_set_t, series_set_elt_value_t> series_set_elt_t;

      typedef typename series_set_t::monoid_t           monoid_t;

      typedef typename series_set_elt_t::monoid_elt_t   monoid_elt_t;

      typedef typename monoid_elt_t::value_t            monoid_elt_value_t;

      typedef typename monoid_t::letter_t               letter_t;

      typedef typename series_set_t::semiring_t         semiring_t;

      typedef typename series_set_elt_t::semiring_elt_t semiring_elt_t;

      typedef typename series_set_elt_t::semiring_elt_value_t
      semiring_elt_value_t;

      typedef typename automaton_traits<T>::tag_t               tag_t;

      typedef typename automaton_traits<T>::label_t     label_t;

      typedef typename automaton_traits<T>::states_t    states_t;

      typedef typename automaton_traits<T>::state_iterator state_iterator;

      typedef typename automaton_traits<T>::transitions_t transitions_t;

      typedef typename automaton_traits<T>::transition_iterator transition_iterator;

      typedef typename automaton_traits<T>::initial_t   initial_t;

      typedef typename automaton_traits<T>::initial_support_t initial_support_t;

      typedef typename automaton_traits<T>::initial_iterator initial_iterator;

      typedef typename automaton_traits<T>::final_t     final_t;

      typedef typename automaton_traits<T>::final_iterator final_iterator;

      typedef typename automaton_traits<T>::geometry_t  geometry_t;

      const series_set_t& series() const;

      tag_t& tag();

      const tag_t& tag() const;

      geometry_t& geometry();

      const geometry_t& geometry() const;

      bool exists() const;

      typename automaton_traits<T>::states_t
      states() const;

      typename automaton_traits<T>::transitions_t
      transitions() const;

      typename automaton_traits<T>::initial_support_t
      initial() const;

      typename automaton_traits<T>::final_support_t
      final() const;

      bool is_initial(hstate_t state) const;

      bool is_final(hstate_t state) const;

      void set_initial(hstate_t state);

      void set_initial(hstate_t state, const series_set_elt_t& m);

      void set_final(hstate_t state);

      void set_final(hstate_t state, const series_set_elt_t& m);

      void unset_initial(hstate_t state);

      void unset_final(hstate_t state);

      void clear_initial();

      void clear_final();

      Element<series_set_t, series_set_elt_value_t>
      get_initial(hstate_t state) const;

      Element<series_set_t, series_set_elt_value_t>
      get_final(hstate_t what) const;

      hstate_t add_state();

      hstate_t choose_state() const;

      htransition_t add_transition(hstate_t from, hstate_t to, const label_t& label);

      htransition_t add_weighted_transition(hstate_t from, hstate_t to,
                                            const semiring_elt_t& w,
                                            const monoid_elt_value_t& m);

      htransition_t add_series_transition(hstate_t from, hstate_t to,
                                          const series_set_elt_t& e);

      htransition_t add_spontaneous(hstate_t from, hstate_t to,
                                    const semiring_elt_t& w);

      htransition_t add_spontaneous(hstate_t from, hstate_t to);

      htransition_t add_letter_transition(hstate_t from, hstate_t to,
                                          const letter_t& l);

      void update(htransition_t e, const label_t& l);

      void del_state(hstate_t s);

      void del_transition(htransition_t e);

      bool has_state(hstate_t s) const;

      bool has_transition(htransition_t e) const;

      hstate_t src_of(htransition_t e) const;

      hstate_t dst_of(htransition_t e) const;

      typename automaton_traits<T>::label_t
      label_of(htransition_t e) const;

      series_set_elt_t series_of(htransition_t e) const;

      series_set_elt_value_t series_value_of(htransition_t e) const;

      bool is_spontaneous(htransition_t e) const;

      monoid_elt_t word_of(htransition_t e) const;

      semiring_elt_t weight_of(htransition_t e) const;

      monoid_elt_value_t word_value_of(htransition_t e) const;

      letter_t letter_of(htransition_t e) const;

      // output_return_type = OutputIterator
      // output_type        = htransition_t
      // direction        = output

      template <typename OutputIterator>
      void delta(OutputIterator res,
                 hstate_t from,
                 delta_kind::transitions k) const;

      template <typename OutputIterator, typename L>
      void delta(OutputIterator res,
                 hstate_t from,
                 const L& query,
                 delta_kind::transitions k) const;

      template <typename OutputIterator, typename L>
      void letter_delta(OutputIterator res,
                        hstate_t from,
                        const L& letter,
                        delta_kind::transitions k) const;

      template <typename OutputIterator>
      void spontaneous_delta(OutputIterator res,
                             hstate_t from,
                             delta_kind::transitions k) const;

      // output_return_type = Container
      // output_type        = htransition_t
      // direction        = output

      template <typename Container>
      void deltac(Container& res, hstate_t from, delta_kind::transitions k) const;

      template <typename Container, typename L>
      void deltac(Container& res,
                  hstate_t from,
                  const L& query,
                  delta_kind::transitions k) const;

      template <typename Container, typename L>
      void letter_deltac(Container& res,
                         hstate_t from,
                         const L& letter,
                         delta_kind::transitions k) const;

      template <typename Container>
      void spontaneous_deltac(Container& res,
                              hstate_t from,
                              delta_kind::transitions k) const;

      // output_return_type = OutputIterator
      // output_type        = hstate_t
      // direction        = output

      template <typename OutputIterator>
      void delta(OutputIterator res,
                 hstate_t from,
                 delta_kind::states k) const;

      template <typename OutputIterator, typename L>
      void delta(OutputIterator res,
                 hstate_t from,
                 const L& query,
                 delta_kind::states k) const;

      template <typename OutputIterator, typename L>
      void letter_delta(OutputIterator res,
                        hstate_t from,
                        const L& letter,
                        delta_kind::states k) const;

      template <typename OutputIterator>
      void spontaneous_delta(OutputIterator res,
                             hstate_t from,
                             delta_kind::states k) const;

      // output_return_type = Container
      // output_type        = hstate_t
      // direction        = output

      template <typename Container>
      void deltac(Container& res, hstate_t from, delta_kind::states k) const;

      template <typename Container, typename L>
      void deltac(Container& res,
                  hstate_t from,
                  const L& query,
                  delta_kind::states k) const;

      template <typename Container, typename L>
      void letter_deltac(Container& res,
                         hstate_t from,
                         const L& letter,
                         delta_kind::states k) const;

      template <typename Container>
      void spontaneous_deltac(Container& res,
                              hstate_t from,
                              delta_kind::states k) const;

      // output_return_type = OutputIterator
      // output_type        = htransition_t
      // direction        = input

      template <typename OutputIterator>
      void rdelta(OutputIterator res,
                  hstate_t from,
                  delta_kind::transitions k) const;

      template <typename OutputIterator, typename L>
      void rdelta(OutputIterator res,
                  hstate_t from,
                  const L& query,
                  delta_kind::transitions k) const;

      template <typename OutputIterator, typename L>
      void letter_rdelta(OutputIterator res,
                         hstate_t from,
                         const L& letter,
                         delta_kind::transitions k) const;

      template <typename OutputIterator>
      void spontaneous_rdelta(OutputIterator res,
                              hstate_t from,
                              delta_kind::transitions k) const;

      // output_return_type = Container
      // output_type        = htransition_t
      // direction        = input

      template <typename Container>
      void rdeltac(Container& res, hstate_t from, delta_kind::transitions k) const;

      template <typename Container, typename L>
      void rdeltac(Container& res,
                   hstate_t from,
                   const L& query,
                   delta_kind::transitions k) const;

      template <typename Container, typename L>
      void letter_rdeltac(Container& res,
                          hstate_t from,
                          const L& letter,
                          delta_kind::transitions k) const;

      template <typename Container>
      void spontaneous_rdeltac(Container& res,
                               hstate_t from,
                               delta_kind::transitions k) const;


      // output_return_type = OutputIterator
      // output_type        = hstate_t
      // direction        = input

      template <typename OutputIterator>
      void rdelta(OutputIterator res,
                  hstate_t from,
                  delta_kind::states k) const;

      template <typename OutputIterator, typename L>
      void rdelta(OutputIterator res,
                  hstate_t from,
                  const L& query,
                  delta_kind::states k) const;

      template <typename OutputIterator, typename L>
      void letter_rdelta(OutputIterator res,
                         hstate_t from,
                         const L& letter,
                         delta_kind::states k) const;

      template <typename OutputIterator>
      void spontaneous_rdelta(OutputIterator res,
                              hstate_t from,
                              delta_kind::states k) const;

      // output_return_type = Container
      // output_type        = hstate_t
      // direction        = input

      template <typename Container>
      void rdeltac(Container& res, hstate_t from, delta_kind::states k) const;

      template <typename Container, typename L>
      void rdeltac(Container& res,
                   hstate_t from,
                   const L& query,
                   delta_kind::states k) const;

      template <typename Container, typename L>
      void letter_rdeltac(Container& res,
                          hstate_t from,
                          const L& letter,
                          delta_kind::states k) const;

      template <typename Container>
      void spontaneous_rdeltac(Container& res,
                               hstate_t from,
                               delta_kind::states k) const;

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

  template <typename S, typename St, typename T>
  St& op_rout(const AutomataBase<S>& s, St& st, const T& r);

} // vcsn

# ifndef VCSN_USE_INTERFACE_ONLY
#  include <vaucanson/automata/concept/automata_base.hxx>
# endif // VCSN_USE_INTERFACE_ONLY

#endif // ! VCSN_AUTOMATA_CONCEPT_AUTOMATA_BASE_HH

---