recursive_union.hpp

Go to the documentation of this file.

#if !defined (RECURSIVE_UNION_93F14ED0_E99B_4CF3_8A9B_EBE084D9079C_H)
#  define RECURSIVE_UNION_93F14ED0_E99B_4CF3_8A9B_EBE084D9079C_H


#  include <pgs/logical.hpp>
#  include <pgs/recursive_wrapper.hpp>
#  include <pgs/type_traits.hpp>

#  include <stdexcept>
#  include <type_traits>
#  include <iostream>

namespace pgs {

  template <class> struct constructor {};

  template <class...> struct recursive_union {};

  template <class T> struct overload_tag {};

  template <bool is_recursive_wrapper, class T, class... Ts>
  struct recursive_union_dereference {

    static constexpr T& ref (recursive_union<T, Ts...>& u) {
      return u.v;
    }
    static constexpr T const& ref (recursive_union<T, Ts...> const& u) {
      return u.v;
    }
    static constexpr T* ptr (recursive_union<T, Ts...>& u) {
      return std::addressof (u.v);
    }
    static constexpr T const* ptr (recursive_union<T, Ts...> const& u) {
      return std::addressof (u.v);
    }
  };

  template <class T, class... Ts>
  struct recursive_union_dereference<true, T, Ts...> {

    static auto ref (recursive_union<T, Ts...>& u)
      -> decltype (u.v.get ()) {
      return u.v.get ();
    }
    static auto ref (recursive_union<T, Ts...> const& u)
      -> decltype (u.v.get ()) {
      return u.v.get ();
    }
    static constexpr auto ptr (recursive_union<T, Ts...>& u) 
      -> decltype (u.v.get_pointer ()) {
      return u.v.get_pointer ();
    }
    static constexpr auto ptr (recursive_union<T, Ts...> const& u) 
      -> decltype (u.v.get_pointer ()) {
      return u.v.get_pointer ();
    }
  };

  template<std::size_t I, class T, class... Ts>
  struct recursive_union_indexer {

    static constexpr auto ref (recursive_union<T, Ts...>& u)
      -> decltype (recursive_union_indexer<I - 1, Ts...>::ref (u.r))
    {
      return recursive_union_indexer<I - 1, Ts...>::ref (u.r);
    }
    static constexpr auto ref (recursive_union<T, Ts...> const& u) 
      -> decltype (recursive_union_indexer<I - 1, Ts...>::ref (u.r))
    {
      return recursive_union_indexer<I - 1, Ts...>::ref (u.r);
    }
    static constexpr auto ptr (recursive_union<T, Ts...>& u) 
      -> decltype (recursive_union_indexer<I - 1, Ts...>::ptr (u.r)) {
      return recursive_union_indexer<I - 1, Ts...>::ptr (u.r);
    }
    static constexpr auto ptr (recursive_union<T, Ts...> const& u) 
      -> decltype (recursive_union_indexer<I - 1, Ts...>::ptr (u.r)) {
      return recursive_union_indexer<I - 1, Ts...>::ptr (u.r);
    }
  };

  template <class T, class... Ts>
  struct recursive_union_indexer<0, T, Ts...> {
    static constexpr auto ref (recursive_union<T, Ts...>& u) 
      -> decltype (recursive_union_dereference<is_recursive_wrapper<T>::value, T, Ts...>::ref (u)) {
      return recursive_union_dereference<is_recursive_wrapper<T>::value, T, Ts...>::ref (u);
    }
    static constexpr auto ref (recursive_union<T, Ts...> const& u) 
      -> decltype (recursive_union_dereference<is_recursive_wrapper<T>::value, T, Ts...>::ref (u)) {
      return recursive_union_dereference<is_recursive_wrapper<T>::value, T, Ts...>::ref (u);
    }
    static constexpr auto ptr (recursive_union<T, Ts...>& u) 
      -> decltype ((recursive_union_dereference<is_recursive_wrapper<T>::value, T, Ts...>::ptr (u))) {
      return recursive_union_dereference<is_recursive_wrapper<T>::value, T, Ts...>::ptr (u);
    }
    static constexpr auto ptr (recursive_union<T, Ts...> const& u) 
      -> decltype (recursive_union_dereference<is_recursive_wrapper<T>::value, T, Ts...>::ptr (u)) {
      return recursive_union_dereference<is_recursive_wrapper<T>::value, T, Ts...>::ptr (u);
    }
  };

  template <class R, class T, class... Ts>
  struct recursive_union_visitor {

    using result_type = R; 

    template <
      class O, class F, class... Fs,
      class = pgs::enable_if_t<is_callable<F, T>::value, void>
      >
    static result_type visit (overload_tag<O>, T const& t, F&& f, Fs&&...) {
      return std::forward<F>(f)(t);
    }
    template <
      class F, class O, class... Fs,
      class = pgs::enable_if_t<!is_callable<F, T>::value, void>
      >
    static result_type visit (overload_tag<O> o, T const& t, F&&, Fs&&... fs) {
      return recursive_union_visitor::visit (o, t, std::forward<Fs>(fs)...);
    }
    template <
      class O, class F, class... Fs,
      class = pgs::enable_if_t<is_callable<F, T>::value, void>
      >
    static result_type visit (overload_tag<O>, T& t, F&& f, Fs&&...) {
      return std::forward<F>(f)(t);
    }
    template <
      class F, class O, class... Fs,
      class = pgs::enable_if_t<!is_callable<F, T>::value, void>
      >
    static result_type visit (overload_tag<O> o, T& t, F&&, Fs&&...fs) {
      return recursive_union_visitor::visit (o, t, std::forward<Fs>(fs)...);
    }
  };

  template <class T, class... Ts>
  struct recursive_union_visitor<void, T, Ts...> {

    using result_type = void;

    template <
      class O, class F, class... Fs,
      class = pgs::enable_if_t<is_callable<F, T>::value, void>
      >
    static result_type visit (overload_tag<O>, T const& t, F&& f, Fs&&...) {
      std::forward<F>(f)(t);
    }
    template <
      class F, class O, class... Fs,
      class = pgs::enable_if_t<!is_callable<F, T>::value, void>
      >
    static result_type visit (overload_tag<O> o, T const& t, F&&, Fs&&... fs) {
      recursive_union_visitor::visit (o, t, std::forward<Fs>(fs)...);
    }
    template <
      class O, class F, class... Fs,
      class = pgs::enable_if_t<is_callable<F, T>::value, void>
      >
    static result_type visit (overload_tag<O>, T& t, F&& f, Fs&&...) {
      std::forward<F>(f)(t);
    }
    template <
      class F, class O, class... Fs,
      class = pgs::enable_if_t<!is_callable<F, T>::value, void>
      >
    static result_type visit (overload_tag<O> o, T& t, F&&, Fs&&...fs) {
      recursive_union_visitor::visit (o, t, std::forward<Fs>(fs)...);
    }
  };

  struct invalid_sum_type_access : std::logic_error {
    explicit invalid_sum_type_access (std::string const& what)
      : std::logic_error {what}
    {}
    explicit invalid_sum_type_access (std::string&& what)
      : std::logic_error {std::move (what)}
    {}
    explicit invalid_sum_type_access (char const* what)
      : std::logic_error {what}
    {}
  };

  template <std::size_t...> struct range {};

  namespace detail {
    template <std::size_t Z, std::size_t N, std::size_t... Ns>
    struct mk_range  : mk_range <Z, N - 1, N, Ns...>
    {};

    template <std::size_t Z, std::size_t... Ns>
    struct mk_range<Z, Z, Ns...> {
      using type = range<Z, Ns...>;
    };
  }//namespace detail

  template <std::size_t Z, std::size_t N>
  using range_t =  typename detail::mk_range<Z, N>::type;

  template <class R, class... Ts>
  struct recursive_union_visitor<R, range<>, Ts...> {
  
    using result_type = R;
  
    template <class... Fs>
    static result_type visit (
      recursive_union<Ts...> const&, std::size_t, Fs&&...) {
      throw invalid_sum_type_access{""};
    }

    template <class... Fs>
    static result_type visit (recursive_union<Ts...>&, std::size_t, Fs&&...) {
      throw invalid_sum_type_access{""};
    }
  };
  
  template <class... Ts>
  struct recursive_union_visitor<void, range<>, Ts...> {
  
    using result_type = void;
  
    template <class... Fs>
    static result_type visit (
      recursive_union<Ts...> const&, std::size_t, Fs&&...) {
      throw invalid_sum_type_access{""};
    }
  
    template <class... Fs>
    static result_type visit (
      recursive_union<Ts...>&, std::size_t, Fs&&...) {
      throw invalid_sum_type_access{""};
    }
  };
  
  template <class R, std::size_t I, std::size_t... Is, class T, class... Ts>
  struct recursive_union_visitor<R, range<I, Is...>, T, Ts...> {
  
    using type = T; 
    using result_type = R; 
  
    template <class... Fs>
    static result_type visit (
      recursive_union<type, Ts...> const& u, std::size_t i, Fs&&... fs) {
      if (i == I) {
        //'u' is not a reference (no call 'get ()')
        overload_tag<type> o{};
        return recursive_union_visitor<result_type, T>::visit(
                                        o, u.v, std::forward<Fs>(fs)...);
      }
      else {
        return recursive_union_visitor<result_type, range<Is...>, Ts...>::visit(
                                         u.r, i, std::forward<Fs>(fs)...);
      }
    }
  
    template <class... Fs>
    static result_type visit (
      recursive_union<T, Ts...>& u, std::size_t i, Fs&&... fs) {
      if (i == I) {
        //'u' is not a reference (no call 'get ()')
        overload_tag<T> o{};
        return recursive_union_visitor<result_type, T>::visit(
                                          o, u.v, std::forward<Fs>(fs)...);
      }
      else {
        return recursive_union_visitor<result_type, range<Is...>, Ts...>::visit(
                                           u.r, i, std::forward<Fs>(fs)...);
      }
    }
  };
  
  template <class R, std::size_t I, std::size_t... Is, class T, class... Ts>
  struct recursive_union_visitor<R, range<I, Is...>, recursive_wrapper<T>, Ts...> {
  
    using type = T; 
    using U = recursive_wrapper<type>;
    using result_type = R; 
    
    template <class... Fs>
    static result_type visit (
       recursive_union<U, Ts...> const& u, std::size_t i, Fs&&... fs) {
      if (i == I) {
        //'u' is of type recursive_wrapper<type>, call 'get ()'
        overload_tag<type> o{};
        return recursive_union_visitor<result_type, type>::visit(
                                     o, u.v.get (), std::forward<Fs>(fs)...);
      }
      else {
        return recursive_union_visitor<result_type, range<Is...>, Ts...>::visit(
                                            u.r, i, std::forward<Fs>(fs)...);
      }
    }
  
    template <class... Fs>
    static result_type visit (
      recursive_union<U, Ts...>& u, std::size_t i, Fs&&... fs) {
      if (i == I) {
        //'u' is of type recursive_wrapper<type>, call 'get ()'
        overload_tag<type> o{};
        return recursive_union_visitor<result_type, T>::visit(
                                      o, u.v.get (), std::forward<Fs>(fs)...);
      }
      else {
        return recursive_union_visitor<result_type, range<Is...>, Ts...>::visit(
                                             u.r, i, std::forward<Fs>(fs)...);
      }
    }
  };
  
  template <std::size_t I, std::size_t... Is, class T, class... Ts>
  struct recursive_union_visitor<void, range<I, Is...>, T, Ts...> {
  
    using type = T; 
    using result_type = void; 
  
    template <class... Fs>
    static result_type
    visit (
      recursive_union<type, Ts...> const& u, std::size_t i, Fs&&... fs) {
      if (i == I) {
        //'u' is not a wrapper (no call 'get ()')
        overload_tag<type> o{};
        recursive_union_visitor<result_type, type>::visit(
                                              o, u.v, std::forward<Fs>(fs)...);
      }
      else {
        recursive_union_visitor<result_type, range<Is...>, Ts...>::visit(
                                              u.r, i, std::forward<Fs>(fs)...);
      }
    }
  
    template <class... Fs>
    static result_type
    visit (
      recursive_union<T, Ts...>& u, std::size_t i, Fs&&... fs) {
      if (i == I) {
        //'u' is not a wrapper (no call 'get ()')
        overload_tag<type> o{};
        recursive_union_visitor<result_type, type>::visit(
                                              o, u.v, std::forward<Fs>(fs)...);
      }
      else {
        recursive_union_visitor<result_type, range<Is...>, Ts...>::visit(
                                              u.r, i, std::forward<Fs>(fs)...);
      }
    }
  
  };
  
  template <std::size_t I, std::size_t... Is, class T, class... Ts>
  struct recursive_union_visitor<
     void, range<I, Is...>, recursive_wrapper<T>, Ts...> {

    //U='recursive_wrapper<T>', 'Ts', return type 'void'
  
    using type = T; 
    using U = recursive_wrapper<type>;
    using result_type = void;
  
    template <class... Fs>
    static result_type visit (
       recursive_union<U, Ts...> const& u, std::size_t i, Fs&&... fs) {
      if (i == I) {
        //'u' is a reference (call 'get ()')
        overload_tag<type> o{};
        recursive_union_visitor<void, type>::visit(
                                       o, u.v.get (), std::forward<Fs>(fs)...);
      }
      else {
        recursive_union_visitor<void, range<Is...>, Ts...>::visit (
                                              u.r, i, std::forward<Fs>(fs)...);
      }
    }
  
    template <class... Fs>
    static result_type visit (
      recursive_union<U, Ts...>& u, std::size_t i, Fs&&... fs) {
      if (i == I) {
        //'u' is a reference (call 'get ()')
        overload_tag<type> o{};
        recursive_union_visitor<void, type>::visit(
                                       o, u.v.get (), std::forward<Fs>(fs)...);
      }
      else {
        recursive_union_visitor<void, range<Is...>, Ts...>::visit(
                                              u.r, i, std::forward<Fs>(fs)...);
      }
    }
  };
  
  template <>
  struct recursive_union<> {
    void copy (std::size_t, recursive_union const&) {}
    void move (std::size_t, recursive_union&&) {}
    void destruct (std::size_t) {}
    bool compare (std::size_t, recursive_union const&) const { return false; }
  };
  
  #  if defined(_MSC_VER)
  #    pragma warning(push)
  #    pragma warning(disable:4624)
  #  endif//defined (_MSC_VER)
  
  template <class T, class... Ts>
  struct recursive_union<T, Ts...> {
  
    recursive_union () 
    {}
  
    template <class... Args>
    explicit recursive_union (constructor<T>, Args&&... args) 
      : v (std::forward<Args>(args)...)
    {}

    template <class U, class... Args,
    pgs::enable_if_t<
      is_recursive_wrapper_containing<T, U>::value, int> = 0
    >
    explicit recursive_union (constructor<U>, Args&&... args)
      noexcept (std::is_nothrow_constructible<U, Args...>::value)
    : v (std::forward<Args>(args)...)
    {}

   template <class U, class... Args,
   pgs::enable_if_t<
      and_<
          not_is_same<T, U>
        , not_is_recursive_wrapper_containing<T, U>>::value, int> = 0
    >
    explicit recursive_union (constructor<U> t, Args&&... args)
      noexcept(
         std::is_nothrow_constructible<Ts..., constructor<U>, Args...>::value
      )
      : r (t, std::forward<Args>(args)...)
    {}
  
    ~recursive_union () 
    {}
  
    void copy (std::size_t i, recursive_union const& u)
      noexcept(
       std::is_nothrow_copy_constructible<T>::value
       && noexcept (std::declval<recursive_union>().r.copy (i - 1, u.r))
      ) {
      //std::cout << "recursive_union.copy ()\n";
      if (i == 0) {
        new (std::addressof (v)) T (u.v);
      }
      else {
        r.copy (i - 1, u.r);
      }
    }
  
    void move (std::size_t i, recursive_union&& u) 
      noexcept (
        std::is_nothrow_move_constructible<T>::value
       && noexcept (std::declval<recursive_union>().r.move (
                                                  i - 1, std::move (u.r)))
       ) {
      //std::cout << "recursive_union.move ()\n";
      if (i == 0) {
        new (std::addressof (v)) T (std::move (u.v));
      }
      else {
        r.move (i - 1, std::move (u.r));
      }
    }
  
    void destruct (std::size_t i)
      noexcept (std::is_nothrow_destructible<T>::value 
       && noexcept (std::declval<recursive_union>().r.destruct (i - 1))) {
      if (i == 0) {
        v.~T ();
      }
      else {
        r.destruct (i - 1);
      }
    }
  
    bool compare (size_t i, recursive_union const& rhs) const 
      noexcept {
        return i == 0 ? v == rhs.v : r.compare (i - 1, rhs.r);
    }
  
    union {
      T v; 
      recursive_union<Ts...> r; 
    };
  };
  
#  if defined(_MSC_VER)
#    pragma warning(pop)
#  endif//defined (_MSC_VER)

}//namespace pgs

#endif