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