partition-automaton.hh

Go to the documentation of this file.

#ifndef VCSN_CORE_PARTITION_AUTOMATON_HH
# define VCSN_CORE_PARTITION_AUTOMATON_HH

# include <map>
# include <set>
# include <vector>

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

namespace vcsn
{
  namespace detail
  {

    template <typename Aut>
    class partition_automaton_impl
      : public automaton_decorator<typename Aut::element_type::automaton_nocv_t>
    {
    public:
      using automaton_t = Aut;
      using automaton_nocv_t = typename automaton_t::element_type::automaton_nocv_t;
      using context_t = context_t_of<automaton_t>;
      using label_t = label_t_of<automaton_t>;
      using super_t = automaton_decorator<automaton_nocv_t>;

      using state_t = state_t_of<automaton_t>;

      using state_name_t = std::set<state_t>;

    private:
      using origins_t = std::map<state_t, state_name_t>;
      origins_t origins_;

      const automaton_t input_;

    public:
      partition_automaton_impl(const automaton_t& input)
        : super_t(input->context())
        , input_(input)
      {}

      static std::string sname()
      {
        return "partition_automaton<" + automaton_t::element_type::sname() + ">";
      }

      std::string vname(bool full = true) const
      {
        return "partition_automaton<" + input_->vname(full) + ">";
      }

      bool state_has_name(state_t s) const
      {
        return s != super_t::pre() && s != super_t::post();
      }

      std::ostream&
      print_state_name(state_t s, std::ostream& o,
                       const std::string& fmt = "text",
                       bool delimit = false) const
      {
        const auto& set = origins_.at(s);
        const char* separator = "";
        if (delimit)
          o << '{';
        for (auto s : set)
          {
            o << separator;
            input_->print_state_name(s, o, fmt, true);
            separator = ", ";
          }
        if (delimit)
          o << '}';
        return o;
      }

      using super_t::new_state;

      state_t
      new_state(const state_name_t& set)
      {
        state_t res = new_state();
        origins_[res] = set;
        return res;
      }

      state_t
      new_state(const std::vector<state_t>& v)
      {
        state_name_t set;
        for (auto s: v)
          set.emplace(s);
        return new_state(std::move(set));
      }
    }; // class
  } // namespace detail

  template <typename Aut>
  using partition_automaton
    = std::shared_ptr<detail::partition_automaton_impl<Aut>>;

} // namespace vcsn

#endif // !VCSN_CORE_PARTITION_AUTOMATON_HH