types.h

   1 #ifndef types_h
   2 #define types_h
   3
   4 #include <sys/types.h>
   5
   6 #include <algorithm>
   7
   8 #include <condition_variable>
   9 using cond = std::condition_variable;
  10 using std::cv_status;
  11
  12 #include <chrono>
  13 using std::chrono::duration_cast;
  14 using std::chrono::microseconds;
  15 using std::chrono::milliseconds;
  16 using std::chrono::nanoseconds;
  17 using std::chrono::seconds;
  18 using std::chrono::steady_clock;
  19 using std::chrono::system_clock;
  20 using std::chrono::time_point;
  21 using std::chrono::time_point_cast;
  22
  23 #include <exception>
  24
  25 #include <fstream>
  26 using std::ifstream;
  27 using std::ofstream;
  28
  29 #include <functional>
  30
  31 #include <iomanip>
  32 #include <iostream>
  33
  34 #include <limits>
  35 using std::numeric_limits;
  36
  37 #include <list>
  38 using std::list;
  39
  40 #include <map>
  41 using std::map;
  42
  43 #include <memory>
  44 using std::enable_shared_from_this;
  45 using std::make_shared;
  46 using std::shared_ptr;
  47 using std::unique_ptr;
  48 using std::weak_ptr;
  49
  50 #include <mutex>
  51 using std::mutex;
  52 using lock = std::unique_lock<std::mutex>;
  53
  54 #include <stdexcept>
  55 using std::runtime_error;
  56
  57 #include <sstream>
  58
  59 #include <string>
  60 using std::string;
  61 using std::to_string;
  62 using std::stoi;
  63
  64 #include <thread>
  65 using std::thread;
  66 using std::call_once;
  67 using std::once_flag;
  68 namespace this_thread {
  69     using namespace std::this_thread;
  70 }
  71
  72 #include <tuple>
  73 using std::tuple;
  74 using std::get;
  75 using std::tie;
  76
  77 #include <type_traits>
  78 using std::decay;
  79 using std::true_type;
  80 using std::false_type;
  81 using std::is_enum;
  82 using std::is_member_function_pointer;
  83 using std::is_same;
  84 using std::underlying_type;
  85 using std::enable_if;
  86 using std::remove_reference;
  87 using std::add_const;
  88
  89 #include <utility>
  90 using std::pair;
  91 using std::declval;
  92 using std::forward;
  93
  94 #include <vector>
  95 using std::vector;
  96
  97 // type traits and manipulators
  98
  99 template <class A, typename I=void> struct is_const_iterable : false_type {};
 100
 101 template<class A> struct is_const_iterable<A,
 102     decltype(declval<A &>().cbegin(), declval<A &>().cend(), void())
 103 > : true_type {};
 104
 105 template <class A, typename I=void> struct supports_emplace_back : false_type {};
 106
 107 template<class A> struct supports_emplace_back<A,
 108     decltype(declval<A &>().emplace_back(declval<typename A::value_type>()), void())
 109 > : true_type {};
 110
 111 template<typename E>
 112 using enum_type_t = typename enable_if<is_enum<E>::value, typename underlying_type<E>::type>::type;
 113 template<typename E> constexpr inline enum_type_t<E> from_enum(E e) noexcept { return (enum_type_t<E>)e; }
 114 template<typename E> constexpr inline E to_enum(enum_type_t<E> value) noexcept { return (E)value; }
 115
 116
 117 template <class A, typename I=void> struct is_tuple_convertible : false_type {};
 118
 119 template<class A> struct is_tuple_convertible<A,
 120     decltype(declval<A &>()._tuple_(), void())
 121 > : true_type {};
 122
 123 // string manipulation
 124
 125 template <class A, class B>
 126 std::ostream & operator<<(std::ostream & o, const pair<A,B> & d) {
 127     return o << "<" << d.first << "," << d.second << ">";
 128 }
 129
 130 template <class C>
 131 inline typename enable_if<is_const_iterable<C>::value, string>::type
 132 implode(const C & v, string delim=" ") {
 133     auto i=v.cbegin(), end=v.cend();
 134     if (i == end)
 135         return string();
 136     std::ostringstream oss;
 137     oss << *i++;
 138     while (i != end)
 139         oss << delim << *i++;
 140     return oss.str();
 141 }
 142
 143 inline vector<string> explode(const string & s, string delim=" ") {
 144     vector<string> out;
 145     size_t start = 0, end = 0;
 146     while ((end = s.find(delim, start)) != string::npos) {
 147         out.push_back(s.substr(start, end - start));
 148         start = end + delim.size();
 149     }
 150     out.push_back(s.substr(start));
 151     return out;
 152 }
 153
 154 template <class A>
 155 typename enable_if<is_const_iterable<A>::value && !is_same<A,string>::value, std::ostream>::type &
 156 operator<<(std::ostream & o, const A & a) {
 157     return o << "[" << implode(a, ", ") << "]";
 158 }
 159
 160 #include "verify.h"
 161 #include "threaded_log.h"
 162
 163 // struct tuple adapter, useful for marshalling and endian swapping.  usage:
 164 //
 165 // struct foo {
 166 //     int a, b;
 167 //     MEMBERS(a, b)
 168 // };
 169
 170 #define MEMBERS(...) \
 171 inline auto _tuple_() -> decltype(tie(__VA_ARGS__)) { return tie(__VA_ARGS__); } \
 172 inline auto _tuple_() const -> decltype(tie(__VA_ARGS__)) { return tie(__VA_ARGS__); }
 173
 174 // struct ordering and comparison operations; requires the use of MEMBERS.
 175 // usage:
 176 //
 177 // LEXICOGRAPHIC_COMPARISON(foo)
 178
 179 #define LEXICOGRAPHIC_OPERATOR(_c_, _op_) \
 180 inline bool operator _op_(const _c_ & b) const { return _tuple_() _op_ b._tuple_(); }
 181
 182 #define LEXICOGRAPHIC_COMPARISON(_c_) \
 183 LEXICOGRAPHIC_OPERATOR(_c_, <) LEXICOGRAPHIC_OPERATOR(_c_, <=) \
 184 LEXICOGRAPHIC_OPERATOR(_c_, >) LEXICOGRAPHIC_OPERATOR(_c_, >=) \
 185 LEXICOGRAPHIC_OPERATOR(_c_, ==) LEXICOGRAPHIC_OPERATOR(_c_, !=)
 186
 187 // crucial tool for tuple indexing in variadic templates
 188 //
 189 // This implementation of tuple_indices is redistributed under the MIT
 190 // License as an insubstantial portion of the LLVM compiler infrastructure.
 191
 192 template <size_t...> struct tuple_indices {};
 193 template <size_t S, class IntTuple, size_t E> struct make_indices_imp;
 194 template <size_t S, size_t... Indices, size_t E> struct make_indices_imp<S, tuple_indices<Indices...>, E> {
 195     typedef typename make_indices_imp<S+1, tuple_indices<Indices..., S>, E>::type type;
 196 };
 197 template <size_t E, size_t... Indices> struct make_indices_imp<E, tuple_indices<Indices...>, E> {
 198     typedef tuple_indices<Indices...> type;
 199 };
 200 template <size_t E, size_t S=0> struct make_tuple_indices {
 201     typedef typename make_indices_imp<S, tuple_indices<>, E>::type type;
 202 };
 203
 204 #define TUPLE_INDICES(_ArgPack_) typename make_tuple_indices<sizeof...(_ArgPack_)>::type()
 205
 206 // Template parameter pack expansion is not allowed in certain contexts, but
 207 // brace initializers (for instance, calls to constructors of empty structs)
 208 // are fair game.
 209 struct pass { template <typename... Args> inline pass(Args && ...) {} };
 210
 211 #include "endian.h"
 212
 213 #ifndef __has_attribute
 214 #define __has_attribute(x) 0
 215 #endif
 216
 217 #if __has_attribute(noreturn)
 218 #define NORETURN [[noreturn]]
 219 #else
 220 #define NORETURN
 221 #endif
 222
 223 #endif