diff options
Diffstat (limited to 'src/common/utils2.hpp')
| -rw-r--r-- | src/common/utils2.hpp | 256 |
1 files changed, 0 insertions, 256 deletions
diff --git a/src/common/utils2.hpp b/src/common/utils2.hpp deleted file mode 100644 index 9af39e5..0000000 --- a/src/common/utils2.hpp +++ /dev/null @@ -1,256 +0,0 @@ -#ifndef UTILS2_HPP -#define UTILS2_HPP - -# include "../sanity.hpp" - -# include <algorithm> -# include <functional> -# include <iterator> -# include <memory> -# include <type_traits> - -# include "iter.hpp" - -# ifdef __clang__ -# define FALLTHROUGH [[clang::fallthrough]] -# else -# define FALLTHROUGH /* fallthrough */ -# endif - -template<class T, class E, E max> -struct earray -{ - // no ctor/dtor and one public member variable for easy initialization - T _data[size_t(max)]; - - T& operator[](E v) - { - return _data[size_t(v)]; - } - - const T& operator[](E v) const - { - return _data[size_t(v)]; - } - - T *begin() - { - return _data; - } - - T *end() - { - return _data + size_t(max); - } - - const T *begin() const - { - return _data; - } - - const T *end() const - { - return _data + size_t(max); - } - - friend bool operator == (const earray& l, const earray& r) - { - return std::equal(l.begin(), l.end(), r.begin()); - } - - friend bool operator != (const earray& l, const earray& r) - { - return !(l == r); - } -}; - -template<class T, class E> -class eptr -{ - T *_data; -public: - eptr(decltype(nullptr)=nullptr) - : _data(nullptr) - {} - - template<E max> - eptr(earray<T, E, max>& arr) - : _data(arr._data) - {} - - T& operator [](E v) - { - return _data[size_t(v)]; - } - - explicit operator bool() - { - return _data; - } - - bool operator not() - { - return not _data; - } -}; - -// std::underlying_type isn't supported until gcc 4.7 -// this is a poor man's emulation -template<class E> -struct underlying_type -{ - static_assert(std::is_enum<E>::value, "Only enums have underlying type!"); - typedef typename std::conditional< - std::is_signed<E>::value, - typename std::make_signed<E>::type, - typename std::make_unsigned<E>::type - >::type type; -}; - -template<class E, bool=std::is_enum<E>::value> -struct remove_enum -{ - typedef E type; -}; -template<class E> -struct remove_enum<E, true> -{ - typedef typename underlying_type<E>::type type; -}; - - -# define ENUM_BITWISE_OPERATORS(E) \ -inline \ -E operator & (E l, E r) \ -{ \ - typedef underlying_type<E>::type U; \ - return E(U(l) & U(r)); \ -} \ -inline \ -E operator | (E l, E r) \ -{ \ - typedef underlying_type<E>::type U; \ - return E(U(l) | U(r)); \ -} \ -inline \ -E operator ^ (E l, E r) \ -{ \ - typedef underlying_type<E>::type U; \ - return E(U(l) ^ U(r)); \ -} \ -inline \ -E& operator &= (E& l, E r) \ -{ \ - return l = l & r; \ -} \ -inline \ -E& operator |= (E& l, E r) \ -{ \ - return l = l | r; \ -} \ -inline \ -E& operator ^= (E& l, E r) \ -{ \ - return l = l ^ r; \ -} \ -inline \ -E operator ~ (E r) \ -{ \ - return E(-1) ^ r; \ -} - -template<class E> -class EnumMath -{ - typedef typename underlying_type<E>::type U; -public: - static - E inced(E v) - { - return E(U(v) + 1); - } -}; - -template<class E> -IteratorPair<ValueIterator<E, EnumMath<E>>> erange(E b, E e) -{ - return {b, e}; -} - -namespace ph = std::placeholders; - -template<class A, class B> -typename std::common_type<A, B>::type min(A a, B b) -{ - return a < b ? a : b; -} - -template<class A, class B> -typename std::common_type<A, B>::type max(A a, B b) -{ - return b < a ? a : b; -} - -template<class T> -struct is_array_of_unknown_bound -: std::is_same<T, typename std::remove_extent<T>::type[]> -{}; - -template<class T, class D=std::default_delete<T>, class... A> -typename std::enable_if<!is_array_of_unknown_bound<T>::value, std::unique_ptr<T, D>>::type make_unique(A&&... a) -{ - return std::unique_ptr<T, D>(new T(std::forward<A>(a)...)); -} - -template<class T, class D=std::default_delete<T>> -typename std::enable_if<is_array_of_unknown_bound<T>::value, std::unique_ptr<T, D>>::type make_unique(size_t sz) -{ - typedef typename std::remove_extent<T>::type E; - return std::unique_ptr<E[], D>(new E[sz]()); -} - -template<class T> -const T& const_(T& t) -{ - return t; -} - -template<class T, class U> -T no_cast(U&& u) -{ - typedef typename std::remove_reference<T>::type Ti; - typedef typename std::remove_reference<U>::type Ui; - typedef typename std::remove_cv<Ti>::type Tb; - typedef typename std::remove_cv<Ui>::type Ub; - static_assert(std::is_same<Tb, Ub>::value, "not no cast"); - return std::forward<U>(u); -} - -template<class T, class U> -T base_cast(U&& u) -{ - static_assert(std::is_reference<T>::value, "must base cast with references"); - typedef typename std::remove_reference<T>::type Ti; - typedef typename std::remove_reference<U>::type Ui; - typedef typename std::remove_cv<Ti>::type Tb; - typedef typename std::remove_cv<Ui>::type Ub; - static_assert(std::is_base_of<Tb, Ub>::value, "not base cast"); - return std::forward<U>(u); -} - -// use this when e.g. U is an int of unknown size -template<class T, class U> -T maybe_cast(U u) -{ - return u; -} - -template<class T, class U> -typename std::remove_pointer<T>::type *sign_cast(U *u) -{ - typedef typename std::remove_pointer<T>::type T_; - static_assert(sizeof(T_) == sizeof(U), "sign cast must be same size"); - return reinterpret_cast<T_ *>(u); -} - -#endif // UTILS2_HPP |