dot.hh

Go to the documentation of this file.

#pragma once

#include <iostream>

#include <vcsn/algos/project.hh> // bad layering: should not be in algos.
#include <vcsn/core/rat/visitor.hh>
#include <vcsn/misc/format.hh>
#include <vcsn/misc/indent.hh>

namespace vcsn
{
  namespace rat
  {
    template <typename ExpSet>
    class dot_printer
      : public ExpSet::const_visitor
    {
    public:
      using expressionset_t = ExpSet;
      using super_t = typename expressionset_t::const_visitor;
      using self_t = dot_printer;

      using context_t = context_t_of<expressionset_t>;
      using identities_t = typename expressionset_t::identities_t;
      using labelset_t = labelset_t_of<context_t>;
      using label_t = label_t_of<context_t>;
      using weight_t = weight_t_of<context_t>;

      using node_t = typename super_t::node_t;
      using value_t = typename node_t::value_t;
      template <type_t Type>
      using constant_t = typename super_t::template constant_t<Type>;
      template <type_t Type>
      using unary_t = typename super_t::template unary_t<Type>;
      template <type_t Type>
      using variadic_t = typename super_t::template variadic_t<Type>;

      constexpr static const char* me() { return "dot_printer"; }

      dot_printer(const expressionset_t& rs, std::ostream& out)
        : out_{out}
        , rs_{rs}
      {
        format(vcsn::format("text"));
      }

      void format(format fmt)
      {
        fmt_ = fmt;
        if (fmt_ == format::latex)
          {
            lgroup_        = "{";
            rgroup_        = "}";
            langle_        = " \\left\\langle ";
            rangle_        = " \\right\\rangle ";
            lparen_        = "\\left(";
            rparen_        = "\\right)";
            lexponent_     = "^{";
            rexponent_     = "}";
            star_          = "^{*}";
            complement_    = "^{c}";
            transposition_ = "^{T}";
            conjunction_   = " \\& ";
            infiltration_  = " \\uparrow ";
            shuffle_       = " \\between ";
            product_       = " \\, ";
            sum_           = (rs_.identities().is_distributive() ? " \\oplus "
                              : " + ");
            zero_          = "\\emptyset";
            one_           = "\\varepsilon";
            lmul_          = "\\,";
            rmul_          = "\\,";
            ldiv_          = " \\backslash ";
            tuple_left     = " \\left. ";
            tuple_middle   = " \\middle| ";
            tuple_right    = " \\right. ";
            exponent_threshold_= 2;
          }
        else if (fmt_ == format::text)
          {
            lgroup_        = "";
            rgroup_        = "";
            langle_        = "<";
            rangle_        = ">";
            lparen_        = "(";
            rparen_        = ")";
            lexponent_     = "{";
            rexponent_     = "}";
            star_          = "*";
            complement_    = "{c}";
            transposition_ = "{T}";
            conjunction_   = "&";
            infiltration_  = "&:";
            shuffle_       = ":";
            product_       = "";
            sum_           = "+";
            zero_          = "\\z";
            one_           = "\\e";
            lmul_          = "";
            rmul_          = "";
            ldiv_          = "{\\}";
            tuple_left     = "";
            tuple_middle   = "|";
            tuple_right    = "";
            exponent_threshold_= 4;
          }
        else if (fmt_ == format::utf8)
          {
            lgroup_        = "";
            rgroup_        = "";
            langle_        = "⟨";
            rangle_        = "⟩";
            lparen_        = "(";
            rparen_        = ")";
            star_          = "*";
            complement_    = "ᶜ";
            transposition_ = "ᵗ";
            conjunction_   = "&";
            infiltration_  = "&:";
            shuffle_       = ":";
            product_       = "";
            sum_           = "+";
            zero_          = "∅";
            one_           = "ε";
            lmul_          = "";
            rmul_          = "";
            ldiv_          = "{\\}";
            tuple_left     = "";
            tuple_middle   = "|";
            tuple_right    = "";
            exponent_threshold_= 2;
          }
        else
          raise("expression: invalid format: ", fmt_);
      }

      std::ostream& operator()(const value_t& v)
      {
        out_ << "digraph" << vcsn::iendl
             << "{" << vcsn::incendl;
        print(v);
        out_ << vcsn::decendl
             << "}";
        return out_;
      }

      std::ostream& print(const value_t& v)
      {
        return print_(*v);
      }

    private:
      std::ostream& print_(const node_t& v)
      {
        v.accept(*this);
        return out_;
      }

      VCSN_RAT_VISIT(atom, v)          { print_(v); }
      VCSN_RAT_VISIT(complement, v)    { print_(v, complement_); }
      VCSN_RAT_VISIT(conjunction, v)   { print_(v, conjunction_); }
      VCSN_RAT_VISIT(infiltration, v)  { print_(v, infiltration_); }
      VCSN_RAT_VISIT(ldiv, v)          { print_(v, ldiv_); }
      VCSN_RAT_VISIT(lweight, v)       { print_(v); }
      VCSN_RAT_VISIT(one, v)           { print_(v, one_); }
      VCSN_RAT_VISIT(prod, v)          { print_(v, product_); }
      VCSN_RAT_VISIT(rweight, v)       { print_(v); }
      VCSN_RAT_VISIT(shuffle, v)       { print_(v, shuffle_); }
      VCSN_RAT_VISIT(star, v)          { print_(v, star_); }
      VCSN_RAT_VISIT(sum, v)           { print_(v, sum_); }
      VCSN_RAT_VISIT(transposition, v) { print_(v, transposition_); }
      VCSN_RAT_VISIT(zero, v)          { print_(v, zero_); }

      using tuple_t = typename super_t::tuple_t;

      template <bool = context_t::is_lat,
                typename Dummy = void>
      struct visit_tuple
      {
        template <size_t I>
        void print_(const tuple_t& v)
        {
          auto rs = detail::project<I>(self_.rs_);
          const auto& r = std::get<I>(v.sub());
          self_.out_
            << vcsn::iendl
            << "x" << address(v) << " -> "
            << "x" << address(*r) << vcsn::iendl;
          auto printer = make_dot_printer(rs, self_.out_);
          printer.format(self_.fmt_);
          printer.print(r);
        }

        template <size_t... I>
        void print_(const tuple_t& v, detail::index_sequence<I...>)
        {
          using swallow = int[];
          (void) swallow
          {
            (print_<I>(v),
             0)...
          };
        }

        void operator()(const tuple_t& v)
        {
          self_.out_ << "x" << address(v)
                     << " [label=\"" << self_.tuple_middle << "\"]";
          print_(v, labelset_t::indices);
        }
        const self_t& self_;
      };

      template <typename Dummy>
      struct visit_tuple<false, Dummy>
      {
        void operator()(const tuple_t&)
        {
          BUILTIN_UNREACHABLE();
        }
        const self_t& self_;
      };

      void visit(const tuple_t& v, std::true_type) override
      {
        visit_tuple<>{*this}(v);
      }

      template <rat::exp::type_t Type>
      void print_(const unary_t<Type>& n, const char* op)
      {
        out_ << "x" << address(n)
             << " [label=\"" << op << "\"]" << vcsn::iendl;
        out_ << "x" << address(n) << " -> "
             << "x" << address(*n.sub()) << vcsn::iendl;
        print(n.sub());
      }

      template <rat::exp::type_t Type>
      void print_(const constant_t<Type>& n, const char* op)
      {
        out_ << "x" << address(n)
             << " [label=\"" << op << "\"]";
      }

      template <rat::exp::type_t Type>
      void print_(const variadic_t<Type>& n, const char* op)
      {
        out_ << "x" << address(n)
             << " [label=\"" << op << "\"]" << vcsn::iendl;
        out_ << "x" << address(n) << " -> {";
        for (const auto& i: n)
          out_ << " x" << address(*i);
        out_ << " }";
        for (const auto& i: n)
          {
            out_ << vcsn::iendl;
            print(i);
          }
      }

      std::ostream& print_(const weight_t& w)
      {
        out_ << "x" << address(w) << " [label=\"";
        rs_.weightset()->print(w, out_, fmt_.for_weights());
        return out_ << "\"]";
      }

      void print_(const lweight_t& n)
      {
        out_ << "x" << address(n)
             << " [label=\"lweight\"]" << vcsn::iendl
             << "x" << address(n) << " -> {"
             << " x" << address(n.weight())
             << " x" << address(*n.sub())
             << " }" << vcsn::iendl;
        print_(n.weight()) << vcsn::iendl;
        print(n.sub());
      }

      void print_(const rweight_t& n)
      {
        out_ << "x" << address(n)
             << " [label=\"rweight\"]" << vcsn::iendl
             << "x" << address(n) << " -> {"
             << " x" << address(*n.sub())
             << " x" << address(n.weight())
             << " }" << vcsn::iendl;
        print(n.sub()) << vcsn::iendl;
        print_(n.weight());
      }

      void print_(const atom_t& n)
      {
        out_ << "x" << address(n)
             << " [label=\"";
        rs_.labelset()->print(n.value(), out_, fmt_.for_labels());
        out_ << "\"]";
      }

      std::ostream& out_;
      class format fmt_;
      const expressionset_t& rs_;
      const bool debug_ = !!getenv("VCSN_PARENS");

      const char* lgroup_ = nullptr;
      const char* rgroup_ = nullptr;
      const char* langle_ = nullptr;
      const char* rangle_ = nullptr;
      const char* lparen_ = nullptr;
      const char* rparen_ = nullptr;
      const char* lexponent_ = nullptr;
      const char* rexponent_ = nullptr;
      const char* lmul_ = nullptr;
      const char* rmul_ = nullptr;
      const char* ldiv_ = nullptr;
      const char* star_ = nullptr;
      const char* complement_ = nullptr;
      const char* transposition_ = nullptr;
      const char* conjunction_ = nullptr;
      const char* infiltration_ = nullptr;
      const char* shuffle_ = nullptr;
      const char* product_ = nullptr;
      const char* sum_ = nullptr;

      const char* tuple_left = nullptr;
      const char* tuple_middle = nullptr;
      const char* tuple_right = nullptr;

      const char* zero_ = nullptr;
      const char* one_ = nullptr;
      unsigned int exponent_threshold_ = 0;
    };

    template <typename ExpSet>
    dot_printer<ExpSet>
    make_dot_printer(const ExpSet& rs, std::ostream& out)
    {
      return {rs, out};
    }
  } // namespace rat
} // namespace vcsn