lazy-tuple-automaton.hh

Go to the documentation of this file.

#pragma once

#include <vcsn/core/automaton.hh>
#include <vcsn/core/automaton-decorator.hh>
#include <vcsn/core/transition-map.hh>
#include <vcsn/core/tuple-automaton.hh>

namespace vcsn
{
  namespace detail
  {

    template <typename Decorated,
              bool KeepTransitions,
              bool Lazy,
              typename Aut, typename... Auts>
    class lazy_tuple_automaton
      : public automaton_decorator<tuple_automaton<Aut, Auts...>>
    {
    public:

      using tuple_automaton_t = tuple_automaton<Aut, Auts...>;
      using state_name_t
        = typename tuple_automaton_t::element_type::state_name_t;
      using state_t
        = typename tuple_automaton_t::element_type::state_t;


      template <size_t... I>
      using seq
        = typename tuple_automaton_t::element_type::template seq<I...>;

      using self_t = lazy_tuple_automaton;
      using super_t = automaton_decorator<tuple_automaton_t>;

      using decorated_t = Decorated;

      using weightset_t = weightset_t_of<Aut>;

      using super_t::aut_;

      lazy_tuple_automaton(Aut aut, const Auts&... auts)
        : super_t{make_tuple_automaton(aut, auts...)}
        , transition_maps_{{auts, ws_}...}
      {
        if (Lazy)
          this->set_lazy(this->pre());
      }

      template <typename... T>
      static symbol sname_(const T&... t)
      {
        static symbol res(tuple_automaton_t::element_type::sname_(t...));
        return res;
      }


      auto origins() const
        -> decltype(aut_->origins())
      {
        return aut_->origins();
      }

      template <bool L = Lazy>
      std::enable_if_t<L, void> complete_(state_t s) const
      {
        const auto& orig = origins();
        state_name_t sn = orig.at(s);
        auto& self = static_cast<decorated_t&>(const_cast<self_t&>(*this));
        self.set_lazy(s, false);
        self.add_transitions(s, sn);
      }

      template <bool L = Lazy>
      std::enable_if_t<!L, void> complete_(state_t s) const
      {
        const auto& orig = origins();
        state_name_t sn = orig.at(s);
        static_cast<decorated_t&>(const_cast<self_t&>(*this)).add_transitions(s, sn);
      }


      auto all_out(state_t s) const
        -> decltype(all_out(aut_, s))
      {
        if (this->is_lazy(s))
          complete_(s);
        return vcsn::detail::all_out(aut_, s);
      }

    protected:

      template <typename A>
      using transition_map_t = transition_map<A, weightset_t,
                                              false, true,
                                              KeepTransitions>;


      template <typename... Args>
      state_t state(Args&&... args)
      {
        return aut_->template state<Lazy>(std::forward<Args>(args)...);
      }

      std::tuple<typename transition_map_t<Auts>::map_t&...>
      out_(const state_name_t& ss)
      {
        return out_(ss, aut_->indices);
      }

      template <size_t... I>
      std::tuple<typename transition_map_t<Auts>::map_t&...>
      out_(const state_name_t& ss, seq<I...>)
      {
        return std::tie(std::get<I>(transition_maps_)[std::get<I>(ss)]...);
      }


      const weightset_t& ws_ = *aut_->weightset();

      std::tuple<transition_map_t<Auts>...> transition_maps_;
    };
  }
}