ratexp.hh

Go to the documentation of this file.

#ifndef VCSN_CORE_RAT_RATEXP_HH
# define VCSN_CORE_RAT_RATEXP_HH

# include <vector>
# include <string>

# include <boost/range.hpp> // make_iterator_range

# include <vcsn/core/rat/fwd.hh>
# include <vcsn/core/rat/visitor.hh>
# include <vcsn/ctx/traits.hh>

namespace vcsn
{
  namespace rat
  {

    class exp
    {
    public:
#ifndef COVERAGE
      virtual ~exp() = default;
#endif

      using type_t = rat::type_t;

      virtual type_t type() const = 0;

      bool is_unary() const
      {
        return vcsn::rat::is_unary(type());
      }

      bool is_leaf() const
      {
        type_t t = type();
        return (vcsn::rat::is_constant(t)
                || t == type_t::atom);
      }
    };


    /*-------.
    | node.  |
    `-------*/

    template <typename Context>
    class node
      : public std::enable_shared_from_this<node<Context>>
      , public exp
    {
    public:
      using context_t = Context;
      using node_t = rat::node<context_t>;
      using value_t = std::shared_ptr<const node_t>;
      using values_t = std::vector<value_t>;
      using const_visitor = vcsn::rat::const_visitor<context_t>;

      virtual void accept(const_visitor& v) const = 0;
    };

    /*--------.
    | inner.  |
    `--------*/

    template <typename Context>
    class inner
      : public node<Context>
    {
    public:
      using super_t = node<Context>;
      using value_t = typename super_t::value_t;
    };


    /*-----------.
    | variadic.  |
    `-----------*/

    template <exp::type_t Type, typename Context>
    class variadic
      : public inner<Context>
    {
    public:
      static_assert(vcsn::rat::is_variadic(Type), "invalid type");

      using super_t = inner<Context>;
      using value_t = typename super_t::value_t;
      using values_t = typename super_t::values_t;

      using const_iterator = typename values_t::const_iterator;
      // Needed by boost::make_iterator_range, but since we iterate
      // over const value (well, shared_ptr to const values), make it
      // a const_iterator anyway.  Otherwise, clang won't compile.
      using iterator = const_iterator;
      using const_reverse_iterator = typename values_t::const_reverse_iterator;
      using reverse_iterator = const_reverse_iterator;

      virtual type_t type() const { return Type; };

      const_iterator begin() const;
      const_iterator end() const;
      const_reverse_iterator rbegin() const;
      const_reverse_iterator rend() const;
      size_t size() const;

      const value_t operator[](size_t n) const;

      const value_t head() const;
      const value_t back() const;

      auto tail() const -> decltype(boost::make_iterator_range(*this, 1, 0));

      variadic(const values_t& ns = values_t());
      variadic(const variadic& that)
        : super_t(that)
        , sub_(that.sub_)
      {}

      values_t subs() const;

      virtual void accept(typename super_t::const_visitor& v) const;

    private:
      values_t sub_;
    };

    /*--------.
    | unary.  |
    `--------*/

    template <exp::type_t Type, typename Context>
    class unary
      : public inner<Context>
    {
    public:
      static_assert(is_unary(Type), "invalid type");

      using super_t = inner<Context>;
      using value_t = typename super_t::value_t;

      unary(value_t exp);
      virtual type_t type() const { return Type; };

      const value_t sub() const;

      virtual void accept(typename super_t::const_visitor& v) const;

    private:
      value_t sub_;
    };


    /*--------.
    | weight. |
    `--------*/

    template <exp::type_t Type, typename Context>
    class weight_node
      : public inner<Context>
    {
    public:
      static_assert(Type == type_t::lweight
                    || Type == type_t::rweight,
                    "invalid type");

      using super_t = inner<Context>;
      using weight_t = weight_t_of<Context>;
      using value_t = typename super_t::value_t;

      virtual type_t type() const { return Type; };

      const value_t sub() const;
      const weight_t& weight() const;
      void set_weight(const weight_t& w);

      weight_node(const weight_t& w, value_t exp);
      weight_node(const weight_node& that)
        : sub_(that.sub_)
        , weight_(that.weight_)
      {}

      virtual void accept(typename super_t::const_visitor& v) const;

    private:
      value_t sub_;
      weight_t weight_;
    };


    /*-------.
    | leaf.  |
    `-------*/

    template <typename Context>
    class leaf
      : public node<Context>
    {
    public:
      using super_t = node<Context>;
    };


    template <exp::type_t Type, typename Context>
    class constant
      : public leaf<Context>
    {
    public:
      static_assert(is_constant(Type), "invalid type");
      using super_t = leaf<Context>;
      using value_t = typename super_t::value_t;
      using type_t = typename super_t::type_t;

      virtual type_t type() const { return Type; };

      virtual void accept(typename super_t::const_visitor& v) const;
    };


    template <typename Context>
    class atom
      : public leaf<Context>
    {
    public:
      using super_t = leaf<Context>;
      using label_t = label_t_of<Context>;
      using type_t = typename super_t::type_t;
      using value_t = typename super_t::value_t;

      atom(const label_t& value);

      virtual type_t type() const { return type_t::atom; };

      virtual void accept(typename super_t::const_visitor& v) const;
      const label_t& value() const;

    private:
      label_t value_;
    };

  } // namespace rat
} // namespace vcsn

#include <vcsn/core/rat/ratexp.hxx>

#endif // !VCSN_CORE_RAT_RATEXP_HH