11 using std::min_element;
15 #include <condition_variable>
16 using cond = std::condition_variable;
20 using std::chrono::seconds;
21 using std::chrono::milliseconds;
22 using std::chrono::microseconds;
23 using std::chrono::nanoseconds;
24 using std::chrono::steady_clock;
25 using std::chrono::system_clock;
26 using std::chrono::duration_cast;
27 using std::chrono::time_point_cast;
28 using std::chrono::time_point;
37 #ifndef LIBT4_NO_FUNCTIONAL
41 using std::placeholders::_1;
54 using std::setprecision;
60 using std::numeric_limits;
69 using std::enable_shared_from_this;
70 using std::make_shared;
71 using std::shared_ptr;
72 using std::unique_ptr;
77 using lock = std::unique_lock<std::mutex>;
80 using std::ostringstream;
81 using std::istringstream;
92 namespace this_thread {
93 using namespace std::this_thread;
101 #include <type_traits>
103 using std::true_type;
104 using std::false_type;
106 using std::is_member_function_pointer;
108 using std::underlying_type;
109 using std::enable_if;
110 using std::remove_reference;
111 using std::add_const;
121 // type traits and manipulators
123 template <class A, typename I=void> struct is_const_iterable : false_type {};
125 template<class A> struct is_const_iterable<A,
126 decltype(declval<A&>().cbegin(), declval<A&>().cend(), void())
129 template <class A, typename I=void> struct supports_emplace_back : false_type {};
131 template<class A> struct supports_emplace_back<A,
132 decltype(declval<A&>().emplace_back(declval<typename A::value_type>()), void())
136 using enum_type_t = typename enable_if<is_enum<E>::value, typename underlying_type<E>::type>::type;
137 template<typename E> constexpr inline enum_type_t<E> from_enum(E e) noexcept { return (enum_type_t<E>)e; }
138 template<typename E> constexpr inline E to_enum(enum_type_t<E> value) noexcept { return (E)value; }
140 // string manipulation
143 inline typename enable_if<is_const_iterable<C>::value, string>::type
144 implode(const C & v, string delim=" ") {
145 auto i=v.cbegin(), end=v.cend();
151 oss << delim << *i++;
155 inline vector<string> explode(const string &s, string delim=" ") {
157 size_t start = 0, end = 0;
158 while ((end = s.find(delim, start)) != string::npos) {
159 out.push_back(s.substr(start, end - start));
160 start = end + delim.size();
162 out.push_back(s.substr(start));
167 #include "threaded_log.h"
169 // struct tuple adapter, useful for marshalling
176 #define MEMBERS(...) \
177 inline auto _tuple_() -> decltype(tie(__VA_ARGS__)) { return tie(__VA_ARGS__); } \
178 inline auto _tuple_() const -> decltype(tie(__VA_ARGS__)) { return tie(__VA_ARGS__); }
180 // struct ordering and comparison
186 // LEXICOGRAPHIC_COMPARISON(foo)
188 #define LEXICOGRAPHIC_OPERATOR(_c_, _op_) \
189 inline bool operator _op_(const _c_ &b) const { return _tuple_() _op_ b._tuple_(); }
191 #define LEXICOGRAPHIC_COMPARISON(_c_) \
192 LEXICOGRAPHIC_OPERATOR(_c_, <) LEXICOGRAPHIC_OPERATOR(_c_, <=) \
193 LEXICOGRAPHIC_OPERATOR(_c_, >) LEXICOGRAPHIC_OPERATOR(_c_, >=) \
194 LEXICOGRAPHIC_OPERATOR(_c_, ==) LEXICOGRAPHIC_OPERATOR(_c_, !=)
196 // crucial tool for tuple indexing in variadic templates
198 // This implementation of tuple_indices is redistributed under the MIT
199 // License as an insubstantial portion of the LLVM compiler infrastructure.
201 template <size_t...> struct tuple_indices {};
202 template <size_t S, class IntTuple, size_t E> struct make_indices_imp;
203 template <size_t S, size_t... Indices, size_t E> struct make_indices_imp<S, tuple_indices<Indices...>, E> {
204 typedef typename make_indices_imp<S+1, tuple_indices<Indices..., S>, E>::type type;
206 template <size_t E, size_t... Indices> struct make_indices_imp<E, tuple_indices<Indices...>, E> {
207 typedef tuple_indices<Indices...> type;
209 template <size_t E, size_t S=0> struct make_tuple_indices {
210 typedef typename make_indices_imp<S, tuple_indices<>, E>::type type;
213 // Template parameter pack expansion is not allowed in certain contexts, but
214 // brace initializers (for instance, calls to constructors of empty structs)
216 struct pass { template <typename... Args> inline pass(Args&&...) {} };