tagged.tex

%!TEX root = stl2-ts.tex
\infannex{tagged}{Reference implementation for \tcode{tagged}}

\pnum Below is a reference implementation of the \tcode{tagged} class template described in
\ref{taggedtup.tagged}, and also \tcode{tagged_pair}~(\ref{tagged.pairs}),
\tcode{tagged_tuple}~(\ref{tagged.tuple}), and \tcode{tag::in}~(\ref{alg.tagspec}).

\begin{codeblock}
namespace std { namespace experimental { namespace ranges { inline namespace v1 {
  namespace tag { struct __specifier_tag { }; }

  template <class T>
  struct __tag_spec { };
  template <class Spec, class Arg>
  struct __tag_spec<Spec(Arg)> { using type = Spec; };

  template <class T>
  struct __tag_elem { };
  template <class Spec, class Arg>
  struct __tag_elem<Spec(Arg)> { using type = Arg; };

  template <class T>
  concept bool TagSpecifier() {
    return DerivedFrom<T, tag::__specifier_tag>();
  }

  template <class T>
  concept bool TaggedType() {
    return requires {
      typename __tag_spec<T>::type;
      requires TagSpecifier<typename __tag_spec<T>::type>();
    };
  }

  template <class Base, TagSpecifier... Tags>
    requires sizeof...(Tags) >= tuple_size<Base>::value
  struct tagged;
  }}}

  template <class Base, class... Tags>
  struct tuple_size<experimental::ranges::tagged<Base, Tags...>>
    : tuple_size<Base> { };
  template <size_t N, class Base, class... Tags>
  struct tuple_element<N, experimental::ranges::tagged<Base, Tags...>>
    : tuple_element<N, Base> { };

  namespace experimental { namespace ranges { inline namespace v1 {

  struct __getters {
  private:
    template <class, TagSpecifier...>
      requires sizeof...(Tags) >= tuple_size<Base>::value
    friend struct tagged;
    template <class Type, class Indices, TagSpecifier... Tags>
    struct collect_;
    template <class Type, size_t... Is, TagSpecifier... Tags>
    struct collect_<Type, index_sequence<Is...>, Tags...>
      : Tags::template getter<Type, Is>... {
      collect_() = default;
      collect_(const collect_&) = default;
      collect_& operator=(const collect_&) = default;
    private:
      template <class Base, TagSpecifier... Tags>
        requires sizeof...(Tags) <= tuple_size<Base>::value
      friend struct tagged;
      ~collect_() = default;
    };
    template <class Type, TagSpecifier... Tags>
    using collect = collect_<Type, make_index_sequence<sizeof...(Tags)>, Tags...>;
  };

  template <class Base, TagSpecifier... Tags>
  struct tagged
    : Base, __getters::collect<tagged<Base, Tags...>, Tags...> {
    using Base::Base;
    tagged() = default;
    tagged(tagged&&) = default;
    tagged(const tagged&) = default;
    tagged &operator=(tagged&&) = default;
    tagged &operator=(const tagged&) = default;
    template <typename Other>
      requires Constructible<Base, Other>()
    tagged(tagged<Other, Tags...> &&that)
      : Base(static_cast<Other &&>(that)) { }
    template <typename Other>
      requires Constructible<Base, const Other&>()
    tagged(const tagged<Other, Tags...> &that)
      : Base(static_cast<const Other&>(that)) { }
    template <typename Other>
      requires Assignable<Base&, Other>()
    tagged& operator=(tagged<Other, Tags...>&& that) {
      static_cast<Base&>(*this) = static_cast<Other&&>(that);
      return *this;
    }
    template <typename Other>
      requires Assignable<Base&, const Other&>()
    tagged& operator=(const tagged<Other, Tags...>& that) {
      static_cast<Base&>(*this) = static_cast<const Other&>(that);
      return *this;
    }
    template <class U>
      requires Assignable<Base&, U>() && !Same<decay_t<U>, tagged>()
    tagged& operator=(U&& u) {
      static_cast<Base&>(*this) = std::forward<U>(u);
      return *this;
    }
  };

  template <TaggedType F, TaggedType S>
  using tagged_pair =
    tagged<pair<typename __tag_elem<F>::type, typename __tag_elem<S>::type>,
           typename __tag_spec<F>::type, typename __tag_spec<S>::type>;

  template <TaggedType... Types>
  using tagged_tuple =
    tagged<tuple<typename __tag_elem<Types>::type...>,
           typename __tag_spec<Types>::type...>;

  namespace tag {
    struct in : __specifier_tag {
    private:
      friend __getters;
      template <class Derived, size_t I>
      struct getter {
        getter() = default;
        getter(const getter&) = default;
        getter &operator=(const getter&) = default;
        constexpr decltype(auto) in() & {
          return get<I>(static_cast<Derived &>(*this));
        }
        constexpr decltype(auto) in() && {
          return get<I>(static_cast<Derived &&>(*this));
        }
        constexpr decltype(auto) in() const & {
          return get<I>(static_cast<const Derived &>(*this));
        }
      private:
        friend __getters;
        ~getter() = default;
      };
    }
    // Other tag specifiers defined similarly, see \ref{alg.tagspec}
  }
}}}}
\end{codeblock}