tuple.hh

Go to the documentation of this file.

#ifndef VCSN_MISC_TUPLE_HH
# define VCSN_MISC_TUPLE_HH

# include <iostream>
# include <tuple>

# include <vcsn/misc/hash.hh>

namespace vcsn
{

  // These definitions come in handy every time we define variadic tuples.
  namespace detail
  {

    /*-----------------.
    | index_sequence.  |
    `-----------------*/

    // See "Pretty-print std::tuple"
    // <http://stackoverflow.com/questions/6245735>.

    // See O(log N) implementation of integer sequence
    // <http://stackoverflow.com/questions/17424477>

    template<std::size_t...> struct index_sequence
    { using type = index_sequence; };

    template<class S1, class S2> struct concat;

    template<std::size_t... I1, std::size_t... I2>
    struct concat<index_sequence<I1...>, index_sequence<I2...>>
      : index_sequence<I1..., (sizeof...(I1)+I2)...>{};

    template<class S1, class S2>
    using Concat = typename concat<S1, S2>::type;

    template<std::size_t N> struct make_index_sequence;
    template<std::size_t N> using GenSeq =
      typename make_index_sequence<N>::type;

    template<std::size_t N>
    struct make_index_sequence : Concat<GenSeq<N/2>, GenSeq<N - N/2>>{};

    template<> struct make_index_sequence<0> : index_sequence<>{};
    template<> struct make_index_sequence<1> : index_sequence<0>{};

    template<std::size_t off, class S2> struct int_range;

    template<std::size_t off, std::size_t... I>
    struct int_range<off, index_sequence<I...>>
      : index_sequence<I + off...>{};

    template<std::size_t S, std::size_t L>
    struct make_index_range
      : int_range<S, typename make_index_sequence<L>::type>{};

    template<std::size_t S>
    struct make_index_range<S, 0> : index_sequence<>{};
    template<std::size_t S>
    struct make_index_range<S, -1U> : index_sequence<>{};

    template<typename S1, typename S2>
    struct concat_index_sequence;

    template<std::size_t... I1, std::size_t... I2>
    struct concat_index_sequence<index_sequence<I1...>, index_sequence<I2...>>
      : index_sequence<I1..., I2...>{};

    template <typename S1, typename S2>
    using concat_sequence = typename concat_index_sequence<S1, S2>::type;

    // There is a bug in clang making this one useless...
    // The index sequence generated is always <0>
    // Bug report:
    // http://llvm.org/bugs/show_bug.cgi?id=14858
    //template<class... T>
    //using index_sequence_for = make_index_sequence<sizeof...(T)>;


    template <typename Fun, typename... Ts>
    inline void
    for_(const std::tuple<Ts...>& ts, Fun f)
    {
      for_(f, ts, make_index_sequence<sizeof...(Ts)>());
    }

    template <typename Fun, typename... Ts, size_t... I>
    inline void
    for_(Fun f,
         const std::tuple<Ts...>& ts,
         index_sequence<I...>)
    {
      using swallow = int[];
      (void) swallow{ (f(std::get<I>(ts)), 0)... };
    }

    template <typename Fun, typename... Ts>
    inline auto
    map(const std::tuple<Ts...>& ts, Fun f)
      -> decltype(map_tuple_(f, ts, make_index_sequence<sizeof...(Ts)>()))
    {
      return map_tuple_(f, ts, make_index_sequence<sizeof...(Ts)>());
    }

    template <typename Fun, typename... Ts, size_t... I>
    inline auto
    map_tuple_(Fun f,
               const std::tuple<Ts...>& ts,
               index_sequence<I...>)
      -> decltype(map_variadic_(f, std::get<I>(ts)...))
    {
      return map_variadic_(f, std::get<I>(ts)...);
    }

    template<typename Fun>
    inline auto
    map_variadic_(Fun)
      -> decltype(std::make_tuple())
    {
      return std::make_tuple();
    }

    template <typename Fun, typename T, typename... Ts>
    inline auto
    map_variadic_(Fun f, T t, Ts&&... ts)
      -> decltype(std::tuple_cat(std::make_tuple(f(t)), map_variadic_(f, ts...)))
    {
      // Enforce evaluation order from left to right.
      auto r = f(t);
      return std::tuple_cat(std::make_tuple(r), map_variadic_(f, ts...));
    }



#if 0

    /*-----------------.
    | make_gcc_tuple.  |
    `-----------------*/

    // This does not work, I don't understand why.  If you know, please
    // let me (AD) know.
    inline auto
    make_gcc_tuple()
      -> std::tuple<>
    {
      return {};
    }

    template <typename T, typename... Ts>
    inline auto
    make_gcc_tuple(T t, Ts&&... ts)
      -> decltype(std::tuple_cat(make_gcc_tuple(std::forward<Ts>(ts)...), std::make_tuple(t)));

    template <typename T, typename... Ts>
    inline auto
    make_gcc_tuple(T t, Ts&&... ts)
      -> decltype(std::tuple_cat(make_gcc_tuple(std::forward<Ts>(ts)...), std::make_tuple(t)))
    {
      return std::tuple_cat(make_gcc_tuple(std::forward<Ts>(ts)...), std::make_tuple(t));
    }

#endif


    /*----------------.
    | reverse_tuple.  |
    `----------------*/

    template <typename... Ts>
    inline auto
    reverse_tuple(const std::tuple<Ts...>& t)
      -> decltype(reverse_tuple(t, make_index_sequence<sizeof...(Ts)>()))
    {
      return reverse_tuple(t, make_index_sequence<sizeof...(Ts)>());
    }

    template <typename... Ts, std::size_t... I>
    inline auto
    reverse_tuple(const std::tuple<Ts...>& t, index_sequence<I...>)
      -> decltype(std::make_tuple(std::get<sizeof...(Ts) - 1 - I>(t)...))
    {
      return std::make_tuple(std::get<sizeof...(Ts) - 1 - I>(t)...);
    }

#  if VCSN_HAVE_CORRECT_LIST_INITIALIZER_ORDER
    template <typename... Ts>
    inline auto
    make_gcc_tuple(Ts&&... ts)
      -> decltype(std::make_tuple(std::forward<Ts>(ts)...))
    {
      return std::make_tuple(std::forward<Ts>(ts)...);
    }
#  else
    template <typename... Ts>
    inline auto
    make_gcc_tuple(Ts&&... ts)
      -> decltype(reverse_tuple(std::make_tuple(std::forward<Ts>(ts)...)))
    {
      return reverse_tuple(std::make_tuple(std::forward<Ts>(ts)...));
    }
#  endif


    /*------------------------.
    | print(tuple, ostream).  |
    `------------------------*/

    template<class Tuple, std::size_t N>
    struct tuple_printer
    {
      static void print(const Tuple& t, std::ostream& o)
      {
        tuple_printer<Tuple, N-1>::print(t, o);
        o << ", " << std::get<N-1>(t);
      }
    };

    template<class Tuple>
    struct tuple_printer<Tuple, 1>
    {
      static void print(const Tuple& t, std::ostream& o)
      {
        o << std::get<0>(t);
      }
    };

    template <typename... Args>
    std::ostream& print(const std::tuple<Args...>& args, std::ostream& o)
    {
      o << '(';
      tuple_printer<decltype(args), sizeof...(Args)>::print(args, o);
      return o << ')';
    }


    // Compile-time logic
    // See:
    // http://stillmoreperfect.blogspot.fr/2010/03/template-metaprogramming-compile-time.html

    // Test if (c) then T1 else T2
    template<bool c, class T1, class T2>
    struct if_c { typedef T1 type; };

    template<class T1, class T2>
    struct if_c<false, T1, T2> { typedef T2 type; };

    template<class C, class T1, class T2>
    struct if_ : if_c<C::value, T1, T2> {};

    // Test if (c) then F1 else F2 and get the value
    template<bool c, class F1, class F2>
    struct eval_if_c : if_c<c, F1, F2>::type {};

    template<class C, class F1, class F2>
    struct eval_if : if_<C, F1, F2>::type {};

    // And condition on several classes
    template<class... F>
    struct and_;

    template<class F1, class... F>
    struct and_<F1, F...> : eval_if<F1, and_<F...>, std::false_type>::type {};

    template<class F1>
    struct and_<F1> : eval_if<F1, std::true_type, std::false_type>::type {};

    template<>
    struct and_<> : std::true_type::type {};

    // Or condition on several classes
    template<class... F>
    struct or_;

    template<class F1, class... F>
    struct or_<F1, F...> : eval_if<F1, std::true_type, or_<F...>>::type { };

    template<class F1>
    struct or_<F1> : eval_if<F1, std::true_type, std::false_type>::type { };

    template<>
    struct or_<> : std::true_type::type {};
  }

  template<bool... B>
  constexpr bool any_()
  {
    return detail::or_<std::integral_constant<bool, B>...>::value;
  }

  // Static evaluation of the 'and' of the template parameters
  template<bool... B>
  constexpr bool all_()
  {
    return detail::and_<std::integral_constant<bool, B>...>::value;
  }


}

namespace std
{

  /*-------------------------.
  | std::hash(tuple<T...>).  |
  `-------------------------*/

  template <typename... Elements>
  struct hash<std::tuple<Elements...>>
  {
    using value_t = std::tuple<Elements...>;
    using indices_t = vcsn::detail::make_index_sequence<sizeof...(Elements)>;

    std::size_t operator()(const value_t& v) const
    {
      return hash_(v, indices_t{});
    }

  private:
    template <std::size_t... I>
    static std::size_t
    hash_(const value_t& v, vcsn::detail::index_sequence<I...>)
    {
      std::size_t res = 0;
      using swallow = int[];
      (void) swallow
        {
          (std::hash_combine(res, std::get<I>(v)), 0)...
        };
      return res;
    }
  };
}

#endif // !VCSN_MISC_TUPLE_HH