include/xbt/utility.hpp

   1 /* Copyright (c) 2016-2019. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #ifndef XBT_UTILITY_HPP
   8 #define XBT_UTILITY_HPP
   9
  10 #include <tuple>
  11 #include <functional>
  12
  13 namespace simgrid {
  14 namespace xbt {
  15
  16 /** @brief A hash which works with more stuff
  17  *
  18  *  It can hash pairs: the standard hash currently doesn't include this.
  19  */
  20 template <class X> class hash : public std::hash<X> {
  21 };
  22
  23 template <class X, class Y> class hash<std::pair<X, Y>> {
  24 public:
  25   std::size_t operator()(std::pair<X, Y> const& x) const
  26   {
  27     hash<X> h1;
  28     hash<X> h2;
  29     return h1(x.first) ^ h2(x.second);
  30   }
  31 };
  32
  33 /** @brief Comparator class for using with std::priority_queue or boost::heap.
  34  *
  35  * Compare two std::pair by their first element (of type double), and return true when the first is greater than the
  36  * second.  Useful to have priority queues with the smallest element on top.
  37  */
  38 template <class Pair> class HeapComparator {
  39 public:
  40   bool operator()(const Pair& a, const Pair& b) const { return a.first > b.first; }
  41 };
  42
  43 /** @brief Erase an element given by reference from a boost::intrusive::list.
  44  */
  45 template <class List, class Elem> inline void intrusive_erase(List& list, Elem& elem)
  46 {
  47   list.erase(list.iterator_to(elem));
  48 }
  49
  50 // integer_sequence and friends from C++14
  51 // We need them to implement `apply` from C++17.
  52
  53 /** A compile-time sequence of integers (from C++14)
  54  *
  55  * `index_sequence<std::size_t,1,5,7,9>` represents the sequence `(1,5,7,9)`.
  56  *
  57  * @code{.cpp}
  58  * template<class T, std::size_t... I>
  59  * auto extract_tuple(T&& t, integer_sequence<std::size_t, I...>)
  60  *   -> decltype(std::make_tuple(std::get<I>(std::forward<T>(t))...))
  61  * {
  62  *  return std::make_tuple(std::get<I>(std::forward<T>(t))...);
  63  * }
  64  *
  65  * int main()
  66  * {
  67  *   integer_sequence<std::size_t, 1, 3> seq;
  68  *   auto a = std::make_tuple(1, 2.0, false, 'a');
  69  *   auto b = extract_tuple(a, seq);
  70  *   std::cout << std::get<0>(b) << '\n'; // 2
  71  *   std::cout << std::get<1>(b) << '\n'; // a
  72  *   return 0;
  73  * }
  74  * @endcode
  75  */
  76 template<class T, T... N>
  77 class integer_sequence {
  78 };
  79
  80 namespace bits {
  81   template<class T, long long N, long long... M>
  82   struct make_integer_sequence :
  83     make_integer_sequence<T, N-1, N-1, M...>
  84   {};
  85   template<class T, long long... M>
  86   struct make_integer_sequence<T, 0, M...> {
  87     typedef integer_sequence<T, (T) M...> type;
  88   };
  89 }
  90
  91 /** A compile-time sequence of integers of the form `(0,1,2,3,...,N-1)` (from C++14) */
  92 template<class T, T N>
  93 using make_integer_sequence = typename simgrid::xbt::bits::make_integer_sequence<T,N>::type;
  94
  95 /** A compile-time sequence of indices (from C++14) */
  96 template<std::size_t... Ints>
  97 using index_sequence = integer_sequence<std::size_t, Ints...>;
  98
  99 /** A compile-time sequence of indices of the form `(0,1,2,3,...,N-1)` (from C++14) */
 100 template<std::size_t N>
 101 using make_index_sequence = make_integer_sequence<std::size_t, N>;
 102
 103 /** Convert a type parameter pack into a index_sequence (from C++14) */
 104 template<class... T>
 105 using index_sequence_for = make_index_sequence<sizeof...(T)>;
 106
 107 static_assert(std::is_same< make_index_sequence<0>, index_sequence<> >::value, "seq0");
 108 static_assert(std::is_same< make_index_sequence<1>, index_sequence<0> >::value, "seq1");
 109 static_assert(std::is_same< make_index_sequence<2>, index_sequence<0, 1> >::value, "seq2");
 110 static_assert(std::is_same< make_index_sequence<3>, index_sequence<0, 1, 2> >::value, "seq3");
 111 static_assert(std::is_same< index_sequence_for<int,double,float>, make_index_sequence<3> >::value, "seq4");
 112
 113 }
 114 }
 115 #endif