#ifndef types_h
#define types_h
+#include <sys/types.h>
+
#include <algorithm>
using std::copy;
-using std::move;
+using std::count_if;
+using std::find;
using std::max;
using std::min;
using std::min_element;
-using std::find;
-using std::count_if;
+using std::move;
+using std::swap;
+
+#include <condition_variable>
+using cond = std::condition_variable;
+using std::cv_status;
#include <chrono>
-using std::chrono::seconds;
-using std::chrono::milliseconds;
+using std::chrono::duration_cast;
using std::chrono::microseconds;
+using std::chrono::milliseconds;
using std::chrono::nanoseconds;
+using std::chrono::seconds;
using std::chrono::steady_clock;
using std::chrono::system_clock;
-using std::chrono::duration_cast;
-using std::chrono::time_point_cast;
using std::chrono::time_point;
+using std::chrono::time_point_cast;
#include <exception>
using std::exception;
#include <fstream>
-using std::ofstream;
using std::ifstream;
+using std::ofstream;
-#ifndef LIBT4_NO_FUNCTIONAL
#include <functional>
+// std::bind conflicts with BIND(2)
using std::function;
-using std::bind;
using std::placeholders::_1;
-#endif
#include <iomanip>
#include <iostream>
using std::setprecision;
using std::ostream;
using std::istream;
-using std::ostream_iterator;
-using std::istream_iterator;
+using std::ios;
#include <limits>
using std::numeric_limits;
#include <map>
using std::map;
+#include <memory>
+using std::enable_shared_from_this;
+using std::make_shared;
+using std::shared_ptr;
+using std::unique_ptr;
+using std::weak_ptr;
+
#include <mutex>
using std::mutex;
using lock = std::unique_lock<std::mutex>;
-using cond = std::condition_variable;
-using std::cv_status;
#include <sstream>
using std::ostringstream;
#include <thread>
using std::thread;
+using std::call_once;
+using std::once_flag;
+namespace this_thread {
+ using namespace std::this_thread;
+}
#include <tuple>
using std::tuple;
using std::is_same;
using std::underlying_type;
using std::enable_if;
+using std::remove_reference;
+using std::add_const;
#include <utility>
using std::pair;
using std::declval;
+using std::forward;
#include <vector>
using std::vector;
+// type traits and manipulators
+
+template <class A, typename I=void> struct is_const_iterable : false_type {};
+
+template<class A> struct is_const_iterable<A,
+ decltype(declval<A &>().cbegin(), declval<A &>().cend(), void())
+> : true_type {};
-template <class A, typename I=void> struct is_iterable : false_type {};
+template <class A, typename I=void> struct supports_emplace_back : false_type {};
-template<class A> struct is_iterable<A,
- decltype(declval<A&>().cbegin(), declval<A&>().cend(), void())
+template<class A> struct supports_emplace_back<A,
+ decltype(declval<A &>().emplace_back(declval<typename A::value_type>()), void())
> : true_type {};
+template<typename E>
+using enum_type_t = typename enable_if<is_enum<E>::value, typename underlying_type<E>::type>::type;
+template<typename E> constexpr inline enum_type_t<E> from_enum(E e) noexcept { return (enum_type_t<E>)e; }
+template<typename E> constexpr inline E to_enum(enum_type_t<E> value) noexcept { return (E)value; }
+
+// string manipulation
+
template <class C>
-inline typename enable_if<is_iterable<C>::value, string>::type
+inline typename enable_if<is_const_iterable<C>::value, string>::type
implode(const C & v, string delim=" ") {
- if (v.begin() == v.end())
+ auto i=v.cbegin(), end=v.cend();
+ if (i == end)
return string();
ostringstream oss;
- auto last = prev(v.end());
- copy(v.begin(), last, ostream_iterator<typename C::value_type>(oss, delim.c_str()));
- oss << *last;
+ oss << *i++;
+ while (i != end)
+ oss << delim << *i++;
return oss.str();
}
-inline vector<string> explode(const string &s, string delim=" ") {
+inline vector<string> explode(const string & s, string delim=" ") {
vector<string> out;
size_t start = 0, end = 0;
while ((end = s.find(delim, start)) != string::npos) {
out.push_back(s.substr(start, end - start));
- start = end + 1;
+ start = end + delim.size();
}
out.push_back(s.substr(start));
return out;
}
-#include "lang/verify.h"
+#include "verify.h"
#include "threaded_log.h"
+// struct tuple adapter, useful for marshalling
+// used like
+// struct foo {
+// int a, b;
+// MEMBERS(a, b)
+// };
+
#define MEMBERS(...) \
inline auto _tuple_() -> decltype(tie(__VA_ARGS__)) { return tie(__VA_ARGS__); } \
inline auto _tuple_() const -> decltype(tie(__VA_ARGS__)) { return tie(__VA_ARGS__); }
+// struct ordering and comparison
+// used like
+// struct foo {
+// int a, b;
+// MEMBERS(a, b)
+// };
+// LEXICOGRAPHIC_COMPARISON(foo)
+
#define LEXICOGRAPHIC_OPERATOR(_c_, _op_) \
-inline bool operator _op_(const _c_ &b) const { return _tuple_() _op_ b._tuple_(); }
+inline bool operator _op_(const _c_ & b) const { return _tuple_() _op_ b._tuple_(); }
#define LEXICOGRAPHIC_COMPARISON(_c_) \
LEXICOGRAPHIC_OPERATOR(_c_, <) LEXICOGRAPHIC_OPERATOR(_c_, <=) \
LEXICOGRAPHIC_OPERATOR(_c_, >) LEXICOGRAPHIC_OPERATOR(_c_, >=) \
LEXICOGRAPHIC_OPERATOR(_c_, ==) LEXICOGRAPHIC_OPERATOR(_c_, !=)
+// crucial tool for tuple indexing in variadic templates
+//
+// This implementation of tuple_indices is redistributed under the MIT
+// License as an insubstantial portion of the LLVM compiler infrastructure.
+
+template <size_t...> struct tuple_indices {};
+template <size_t S, class IntTuple, size_t E> struct make_indices_imp;
+template <size_t S, size_t... Indices, size_t E> struct make_indices_imp<S, tuple_indices<Indices...>, E> {
+ typedef typename make_indices_imp<S+1, tuple_indices<Indices..., S>, E>::type type;
+};
+template <size_t E, size_t... Indices> struct make_indices_imp<E, tuple_indices<Indices...>, E> {
+ typedef tuple_indices<Indices...> type;
+};
+template <size_t E, size_t S=0> struct make_tuple_indices {
+ typedef typename make_indices_imp<S, tuple_indices<>, E>::type type;
+};
+
+// Template parameter pack expansion is not allowed in certain contexts, but
+// brace initializers (for instance, calls to constructors of empty structs)
+// are fair game.
+struct pass { template <typename... Args> inline pass(Args && ...) {} };
+
+#include "endian.h"
+
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+
+#if __has_attribute(noreturn)
+#define NORETURN [[noreturn]]
+#else
+#define NORETURN
+#endif
+
#endif
projects / invirt/third/libt4.git / blobdiff