printer.hh

Go to the documentation of this file.

#pragma once

#include <iostream>

#include <boost/range/algorithm/sort.hpp>

#include <vcsn/algos/sort.hh> // transition_less.
#include <vcsn/concepts/automaton.hh>
#include <vcsn/labelset/tupleset.hh>
#include <vcsn/weightset/polynomialset.hh>

namespace vcsn
{
  namespace detail
  {
     template <typename LabelSet>
     struct rank
     {
       static constexpr size_t value = 1;
     };

     template <typename... LabelSet>
     struct rank<tupleset<LabelSet...>>
     {
       static constexpr size_t value = tupleset<LabelSet...>::size();
     };

    /*-----------.
    | printer.   |
    `-----------*/

    template <Automaton Aut>
    class printer
    {
    protected:
      using automaton_t = Aut;

    public:
      printer(const automaton_t& aut, std::ostream& out)
        : aut_(aut)
        , os_(out)
      {}

      // Should not be public, but needed by GCC 4.8.1.
      // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58972
      using state_t = state_t_of<automaton_t>;

    protected:
      using context_t = context_t_of<automaton_t>;
      using label_t = label_t_of<automaton_t>;
      using transition_t = transition_t_of<automaton_t>;
      using weightset_t = weightset_t_of<automaton_t>;
      using weight_t = weight_t_of<automaton_t>;
      using polynomialset_t = polynomialset<context_t>;
      using polynomial_t = typename polynomialset_t::value_t;

      using states_t = std::vector<state_t>;

      virtual std::string
      label_(const label_t& l) const
      {
        return ls_.is_one(l) ? "@epsilon" : to_string(ls_, l);
      }

      virtual void print_transition_(transition_t t) const
      {
        aut_->print_state(aut_->src_of(t), os_);
        os_ << ' ' << label_(aut_->label_of(t)) << ' ';
        aut_->print_state(aut_->dst_of(t), os_);
      }

      void print_state_(const state_t s)
      {
        std::vector<transition_t> ts;
        for (auto t : out(aut_, s))
          ts.emplace_back(t);
        boost::sort(ts, detail::transition_less<Aut>{aut_});
        for (auto t : ts)
          {
            os_ << '\n';
            print_transition_(t);
          }
      }

      void print_transitions_()
      {
        for (auto s: aut_->states())
          print_state_(s);
      }

      void list_states_(const states_t& ss)
      {
        for (auto s: ss)
          {
            os_ << ' ';
            aut_->print_state(s, os_);
          }
      }

      states_t initials_()
      {
        states_t res;
        for (auto t: initial_transitions(aut_))
          res.emplace_back(aut_->dst_of(t));
        boost::sort(res);
        return res;
      }

      states_t finals_()
      {
        states_t res;
        for (auto t: final_transitions(aut_))
          res.emplace_back(aut_->src_of(t));
        boost::sort(res);
        return res;
      }

      automaton_t aut_;
      std::ostream& os_;
      const labelset_t_of<automaton_t>& ls_ = *aut_->labelset();
      const weightset_t& ws_ = *aut_->weightset();
      const polynomialset_t ps_{aut_->context()};
      using is_transducer_t =
           std::integral_constant<bool,
                                  2 <= rank<labelset_t_of<automaton_t>>::value>;
      const is_transducer_t is_transducer_ = {};
    };
  }
}