ratexpset.hh

Go to the documentation of this file.

#ifndef VCSN_DYN_RATEXPSET_HH
# define VCSN_DYN_RATEXPSET_HH

# include <memory>  // shared_ptr
# include <set>
# include <string>

# include <vcsn/ctx/traits.hh>
# include <vcsn/dyn/fwd.hh> // dyn::ratexp.
# include <vcsn/core/rat/fwd.hh> // rat::exp_t.

namespace vcsn
{
namespace dyn
{
namespace detail
{

  class ratexpset_base
  {
  public:
    using value_t = rat::exp_t;

    virtual std::string vname(bool full = true) const = 0;

    template <typename RatExpSet>
    ratexpset_wrapper<RatExpSet>& as()
    {
      return dynamic_cast<ratexpset_wrapper<RatExpSet>&>(*this);
    }

    template <typename RatExpSet>
    const ratexpset_wrapper<RatExpSet>& as() const
    {
      return dynamic_cast<const ratexpset_wrapper<RatExpSet>&>(*this);
    }

    virtual rat::identities identities() const = 0;

    virtual value_t zero() const = 0;
    virtual value_t one() const = 0;
    virtual value_t atom(const std::string& w) const = 0;
    virtual value_t add(value_t l, value_t r) const = 0;
    virtual value_t mul(value_t l, value_t r) const = 0;
    virtual value_t conjunction(value_t l, value_t r) const = 0;
    virtual value_t shuffle(value_t l, value_t r) const = 0;
    virtual value_t ldiv(value_t l, value_t r) const = 0;
    virtual value_t rdiv(value_t l, value_t r) const = 0;
    virtual value_t concat(value_t l, value_t r) const = 0;
    virtual value_t star(value_t e) const = 0;

    virtual value_t complement(value_t e) const = 0;

    virtual value_t transposition(value_t e) const = 0;

    virtual value_t lmul(const std::string& w, value_t e) const = 0;

    virtual value_t rmul(value_t e, const std::string& w) const = 0;

    using letter_class_t = std::set<std::pair<std::string, std::string>>;

    virtual value_t letter_class(const letter_class_t& chars,
                                 bool accept = true) const = 0;

    virtual dyn::ratexp make_ratexp(const value_t& v) const = 0;

    virtual value_t conv(std::istream& s) const = 0;

    virtual std::ostream& print(const value_t v, std::ostream& o) const = 0;
  };

  template <typename RatExpSet>
  class ratexpset_wrapper : public ratexpset_base
  {
  public:
    using ratexpset_t = RatExpSet;
    using context_t = context_t_of<ratexpset_t>;
    using super_t = ratexpset_base;
    using label_t = label_t_of<context_t>;
    using weight_t = weight_t_of<context_t>;
    using value_t = typename super_t::value_t;

    ratexpset_wrapper(const ratexpset_t& rs);

    virtual std::string vname(bool full = true) const override
    {
      return ratexpset().vname(full);
    }

    const ratexpset_t& ratexpset() const
    {
      return rs_;
    }

    typename ratexpset_t::value_t down(const value_t& v) const;

    weight_t down(const std::string& w) const;

    virtual dyn::ratexp make_ratexp(const value_t& v) const override;

    /*--------------------------------------.
    | Specializations from ratexpset_base.  |
    `--------------------------------------*/

    virtual rat::identities identities() const override;

    virtual value_t zero() const override;
    virtual value_t one() const override;

    virtual value_t atom(const std::string& w) const override;

    virtual value_t add(value_t l, value_t r) const override;

    virtual value_t mul(value_t l, value_t r) const override;

    virtual value_t conjunction(value_t l, value_t r) const override;

    virtual value_t shuffle(value_t l, value_t r) const override;

    virtual value_t ldiv(value_t l, value_t r) const override;
    virtual value_t rdiv(value_t l, value_t r) const override;

    virtual value_t concat(value_t l, value_t r) const override;

    virtual value_t star(value_t v) const override;

    virtual value_t complement(value_t v) const override;
    virtual value_t transposition(value_t v) const override;

    virtual value_t lmul(const std::string& w, value_t v) const override;

    virtual value_t rmul(value_t v, const std::string& w) const override;

    virtual value_t letter_class(const letter_class_t& chars,
                               bool accept = true) const override;

    virtual value_t conv(std::istream& is) const override;

    virtual std::ostream& print(value_t v, std::ostream& o) const override;

  private:
    template <typename LabelSet_, typename Bool>
    value_t letter_class_(const letter_class_t& chars,
                               bool accept, std::true_type, Bool) const;
    template <typename LabelSet_>
    value_t letter_class_(const letter_class_t& chars,
                               bool accept, std::false_type,
                               std::false_type) const;
    template <typename LabelSet_>
    value_t letter_class_(const letter_class_t& chars,
                               bool accept, std::false_type,
                               std::true_type) const;

    ratexpset_t rs_;
  };
} // namespace detail

  template <typename RatExpSet>
  ratexpset make_ratexpset(const RatExpSet& rs);

} // namespace dyn
} // namespace vcsn

# include <vcsn/dyn/ratexpset.hxx>

#endif // !VCSN_DYN_RATEXPSET_HH