dot-gen.hpp

Go to the documentation of this file.

/*
  DOT-GEN.hpp  -  DSL to generate Graphviz-DOT code

  Copyright (C)         Lumiera.org
    2023,               Hermann Vosseler <Ichthyostega@web.de>

  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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef LIB_DOT_GEN_H
#define LIB_DOT_GEN_H


#include "lib/format-util.hpp"
#include "lib/util.hpp"

#include <utility>
#include <sstream>
#include <string>
#include <vector>


namespace lib {
namespace dot_gen { 
  
  using util::toString;
  using util::isnil;
  using std::string;
  using std::move;
  
  
  struct Code : string
    {
      using string::string;
      Code(string const& c) : string{c}      { }
      Code(string     && c) : string{move(c)}{ }
    };
  
  
  struct Section
    {
      std::vector<string> lines;
      
      Section (string name)
        : lines{"// "+name}
        { }
      
      Section&&
      operator+= (Code const& code)
        {
          lines.emplace_back(code);
          return move(*this);
        }
    };
  
  
  
  struct Node : Code
    {
      Node (size_t id)
        : Code{"N"+toString(id)}
        { }
      
      Node&&
      addAttrib (string def)
        {
          if (back() != ']')
            append ("[");
          else
            {
              resize (length()-2);
              append (", ");
            }
          append (def+" ]");
          return move(*this);
        }
      
      Node&&
      label (string text)
        {
          return addAttrib ("label=\""+text+"\"");
        }
      
      Node&&
      style (Code const& code)
        {
          if (not isnil(code))
            addAttrib (code);
          return move(*this);
        }
    };
  
  
  struct Scope : Code
    {
      Scope (size_t id)
        : Code{"{ /*"+toString(id)+"*/ }"}
        { }
      
      Scope&&
      add (Code const& code)
        {
          resize(length()-1);
          append (code+" }");
          return move(*this);
        }
      
      Scope&&
      rank (string rankSetting)
        {
          return add(Code{"rank="+rankSetting});
        }
    };
  
  inline Node  node  (size_t id) { return Node(id);  }
  inline Scope scope (size_t id) { return Scope(id); }
  
  inline Code
  connect (size_t src, size_t dest)
  {
    return Code{Node(src) +" -> "+ Node(dest)};
  }
  
  
  class DotOut
    {
      std::ostringstream buff_;
      
      static uint const IDENT_STEP = 2;
    public:
      void
      putLine (string line, uint indent=0)
        {
          if (indent)
            buff_ << string(indent,' ');
          buff_   << line
                  << '\n';
        }
      
      void
      put (Code const& code)
        {
          buff_ << code;
        }
      
      void
      put (Section const& sect)
        {
          for (string const& line : sect.lines)
            putLine (line, IDENT_STEP);
        }
      
      template<class P, class...PS>
      void
      put (P const& part, PS const& ...parts)
        {
          put (part);
          putLine ("");
          put (parts...);
        }
      
      operator string()  const
        {
          return buff_.str();
        }
    };
  
  template<class...COD>
  inline DotOut
  digraph (COD ...parts)
  {
    DotOut script;
    script.putLine (Code{"digraph {"});
    script.put (parts...);
    script.putLine (Code{"}"});
    return script;
  }
  
  
}} // namespace lib::dot_gen
#endif /*LIB_DOT_GEN_H*/