#ifndef WTF_StdLibExtras_h
#define WTF_StdLibExtras_h
#include <chrono>
#include <memory>
#include <wtf/Assertions.h>
#include <wtf/CheckedArithmetic.h>
#ifndef DEPRECATED_DEFINE_STATIC_LOCAL
#if COMPILER(GCC) && defined(__APPLE_CC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 1
#define DEPRECATED_DEFINE_STATIC_LOCAL(type, name, arguments) \
static type* name##Ptr = new type arguments; \
type& name = *name##Ptr
#else
#define DEPRECATED_DEFINE_STATIC_LOCAL(type, name, arguments) \
static type& name = *new type arguments
#endif
#endif
#define DEFINE_GLOBAL_FOR_LOGGING(type, name, arguments) \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wglobal-constructors\"") \
_Pragma("clang diagnostic ignored \"-Wexit-time-destructors\"") \
static type name arguments; \
_Pragma("clang diagnostic pop")
#ifndef NDEBUG
#if COMPILER(CLANG)
#define DEFINE_DEBUG_ONLY_GLOBAL(type, name, arguments) DEFINE_GLOBAL_FOR_LOGGING(type, name, arguments)
#else
#define DEFINE_DEBUG_ONLY_GLOBAL(type, name, arguments) \
static type name arguments;
#endif // COMPILER(CLANG)
#else
#define DEFINE_DEBUG_ONLY_GLOBAL(type, name, arguments)
#endif // NDEBUG
#define OBJECT_OFFSETOF(class, field) (reinterpret_cast<ptrdiff_t>(&(reinterpret_cast<class*>(0x4000)->field)) - 0x4000)
#define STRINGIZE(exp) #exp
#define STRINGIZE_VALUE_OF(exp) STRINGIZE(exp)
#if (CPU(ARM) || CPU(MIPS)) && COMPILER(GCC)
template<typename Type>
inline bool isPointerTypeAlignmentOkay(Type* ptr)
{
return !(reinterpret_cast<intptr_t>(ptr) % __alignof__(Type));
}
template<typename TypePtr>
inline TypePtr reinterpret_cast_ptr(void* ptr)
{
ASSERT(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
return reinterpret_cast<TypePtr>(ptr);
}
template<typename TypePtr>
inline TypePtr reinterpret_cast_ptr(const void* ptr)
{
ASSERT(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
return reinterpret_cast<TypePtr>(ptr);
}
#else
template<typename Type>
inline bool isPointerTypeAlignmentOkay(Type*)
{
return true;
}
#define reinterpret_cast_ptr reinterpret_cast
#endif
namespace WTF {
template<typename T>
ALWAYS_INLINE typename std::remove_reference<T>::type&& move(T&& value)
{
static_assert(std::is_lvalue_reference<T>::value, "T is not an lvalue reference; move() is unnecessary.");
using NonRefQualifiedType = typename std::remove_reference<T>::type;
static_assert(!std::is_const<NonRefQualifiedType>::value, "T is const qualified.");
return std::move(value);
}
static const size_t KB = 1024;
static const size_t MB = 1024 * 1024;
inline bool isPointerAligned(void* p)
{
return !((intptr_t)(p) & (sizeof(char*) - 1));
}
inline bool is8ByteAligned(void* p)
{
return !((uintptr_t)(p) & (sizeof(double) - 1));
}
template<typename ToType, typename FromType>
inline ToType bitwise_cast(FromType from)
{
static_assert(sizeof(FromType) == sizeof(ToType), "bitwise_cast size of FromType and ToType must be equal!");
union {
FromType from;
ToType to;
} u;
u.from = from;
return u.to;
}
template<typename ToType, typename FromType>
inline ToType safeCast(FromType value)
{
ASSERT(isInBounds<ToType>(value));
return static_cast<ToType>(value);
}
inline size_t bitCount(unsigned bits)
{
bits = bits - ((bits >> 1) & 0x55555555);
bits = (bits & 0x33333333) + ((bits >> 2) & 0x33333333);
return (((bits + (bits >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline size_t bitCount(uint64_t bits)
{
return bitCount(static_cast<unsigned>(bits)) + bitCount(static_cast<unsigned>(bits >> 32));
}
template<typename T, size_t Size> char (&ArrayLengthHelperFunction(T (&)[Size]))[Size];
#if COMPILER(GCC)
template<typename T> char (&ArrayLengthHelperFunction(T (&)[0]))[0];
#endif
#define WTF_ARRAY_LENGTH(array) sizeof(::WTF::ArrayLengthHelperFunction(array))
inline size_t roundUpToMultipleOf(size_t divisor, size_t x)
{
ASSERT(divisor && !(divisor & (divisor - 1)));
size_t remainderMask = divisor - 1;
return (x + remainderMask) & ~remainderMask;
}
template<size_t divisor> inline size_t roundUpToMultipleOf(size_t x)
{
static_assert(divisor && !(divisor & (divisor - 1)), "divisor must be a power of two!");
return roundUpToMultipleOf(divisor, x);
}
enum BinarySearchMode {
KeyMustBePresentInArray,
KeyMightNotBePresentInArray,
ReturnAdjacentElementIfKeyIsNotPresent
};
template<typename ArrayElementType, typename KeyType, typename ArrayType, typename ExtractKey, BinarySearchMode mode>
inline ArrayElementType* binarySearchImpl(ArrayType& array, size_t size, KeyType key, const ExtractKey& extractKey = ExtractKey())
{
size_t offset = 0;
while (size > 1) {
size_t pos = (size - 1) >> 1;
KeyType val = extractKey(&array[offset + pos]);
if (val == key)
return &array[offset + pos];
if (key < val)
size = pos;
else {
size -= (pos + 1);
offset += (pos + 1);
}
ASSERT(mode != KeyMustBePresentInArray || size);
}
if (mode == KeyMightNotBePresentInArray && !size)
return 0;
ArrayElementType* result = &array[offset];
if (mode == KeyMightNotBePresentInArray && key != extractKey(result))
return 0;
if (mode == KeyMustBePresentInArray) {
ASSERT(size == 1);
ASSERT(key == extractKey(result));
}
return result;
}
template<typename ArrayElementType, typename KeyType, typename ArrayType, typename ExtractKey>
inline ArrayElementType* binarySearch(ArrayType& array, size_t size, KeyType key, ExtractKey extractKey = ExtractKey())
{
return binarySearchImpl<ArrayElementType, KeyType, ArrayType, ExtractKey, KeyMustBePresentInArray>(array, size, key, extractKey);
}
template<typename ArrayElementType, typename KeyType, typename ArrayType, typename ExtractKey>
inline ArrayElementType* tryBinarySearch(ArrayType& array, size_t size, KeyType key, ExtractKey extractKey = ExtractKey())
{
return binarySearchImpl<ArrayElementType, KeyType, ArrayType, ExtractKey, KeyMightNotBePresentInArray>(array, size, key, extractKey);
}
template<typename ArrayElementType, typename KeyType, typename ArrayType, typename ExtractKey>
inline ArrayElementType* approximateBinarySearch(ArrayType& array, size_t size, KeyType key, ExtractKey extractKey = ExtractKey())
{
return binarySearchImpl<ArrayElementType, KeyType, ArrayType, ExtractKey, ReturnAdjacentElementIfKeyIsNotPresent>(array, size, key, extractKey);
}
template<typename ArrayElementType, typename KeyType, typename ArrayType, typename ExtractKey>
inline ArrayElementType* binarySearch(const ArrayType& array, size_t size, KeyType key, ExtractKey extractKey = ExtractKey())
{
return binarySearchImpl<ArrayElementType, KeyType, ArrayType, ExtractKey, KeyMustBePresentInArray>(const_cast<ArrayType&>(array), size, key, extractKey);
}
template<typename ArrayElementType, typename KeyType, typename ArrayType, typename ExtractKey>
inline ArrayElementType* tryBinarySearch(const ArrayType& array, size_t size, KeyType key, ExtractKey extractKey = ExtractKey())
{
return binarySearchImpl<ArrayElementType, KeyType, ArrayType, ExtractKey, KeyMightNotBePresentInArray>(const_cast<ArrayType&>(array), size, key, extractKey);
}
template<typename ArrayElementType, typename KeyType, typename ArrayType, typename ExtractKey>
inline ArrayElementType* approximateBinarySearch(const ArrayType& array, size_t size, KeyType key, ExtractKey extractKey = ExtractKey())
{
return binarySearchImpl<ArrayElementType, KeyType, ArrayType, ExtractKey, ReturnAdjacentElementIfKeyIsNotPresent>(const_cast<ArrayType&>(array), size, key, extractKey);
}
template<typename VectorType, typename ElementType>
inline void insertIntoBoundedVector(VectorType& vector, size_t size, const ElementType& element, size_t index)
{
for (size_t i = size; i-- > index + 1;)
vector[i] = vector[i - 1];
vector[index] = element;
}
WTF_EXPORT_PRIVATE bool isCompilationThread();
}
#if OS(WINCE)
inline void* wtf_bsearch(const void* key, const void* base, size_t count, size_t size, int (*compare)(const void *, const void *))
{
const char* first = static_cast<const char*>(base);
while (count) {
size_t pos = (count - 1) >> 1;
const char* item = first + pos * size;
int compareResult = compare(item, key);
if (!compareResult)
return const_cast<char*>(item);
if (compareResult < 0) {
count -= (pos + 1);
first += (pos + 1) * size;
} else
count = pos;
}
return 0;
}
#define bsearch(key, base, count, size, compare) wtf_bsearch(key, base, count, size, compare)
#endif
enum NotNullTag { NotNull };
inline void* operator new(size_t, NotNullTag, void* location)
{
ASSERT(location);
return location;
}
#if (COMPILER(GCC) && !COMPILER(CLANG) && !GCC_VERSION_AT_LEAST(4, 8, 1))
namespace std {
template<class T> struct is_trivially_destructible {
static const bool value = std::has_trivial_destructor<T>::value;
};
}
#endif
namespace std {
#if !defined(_MSC_VER) || _MSC_VER < 1800
template<class T> struct _Unique_if {
typedef unique_ptr<T> _Single_object;
};
template<class T> struct _Unique_if<T[]> {
typedef unique_ptr<T[]> _Unknown_bound;
};
template<class T, size_t N> struct _Unique_if<T[N]> {
typedef void _Known_bound;
};
template<class T, class... Args> inline typename _Unique_if<T>::_Single_object
make_unique(Args&&... args)
{
return unique_ptr<T>(new T(std::forward<Args>(args)...));
}
template<class T> inline typename _Unique_if<T>::_Unknown_bound
make_unique(size_t n)
{
typedef typename remove_extent<T>::type U;
return unique_ptr<T>(new U[n]());
}
template<class T, class... Args> typename _Unique_if<T>::_Known_bound
make_unique(Args&&...) = delete;
#endif
template<size_t... indexes> struct index_sequence {
static size_t size() { return sizeof...(indexes); }
};
template<size_t currentIndex, size_t...indexes> struct make_index_sequence_helper;
template<size_t...indexes> struct make_index_sequence_helper<0, indexes...> {
typedef std::index_sequence<indexes...> type;
};
template<size_t currentIndex, size_t...indexes> struct make_index_sequence_helper {
typedef typename make_index_sequence_helper<currentIndex - 1, currentIndex - 1, indexes...>::type type;
};
template<size_t length> struct make_index_sequence : public make_index_sequence_helper<length>::type { };
#if COMPILER_SUPPORTS(CXX_USER_LITERALS)
namespace literals {
namespace chrono_literals {
CONSTEXPR inline chrono::seconds operator"" _s(unsigned long long s)
{
return chrono::seconds(static_cast<chrono::seconds::rep>(s));
}
CONSTEXPR chrono::milliseconds operator"" _ms(unsigned long long ms)
{
return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(ms));
}
}
}
#endif
}
using WTF::KB;
using WTF::MB;
using WTF::isCompilationThread;
using WTF::insertIntoBoundedVector;
using WTF::isPointerAligned;
using WTF::is8ByteAligned;
using WTF::binarySearch;
using WTF::tryBinarySearch;
using WTF::approximateBinarySearch;
using WTF::bitwise_cast;
using WTF::safeCast;
#if COMPILER_SUPPORTS(CXX_USER_LITERALS)
using namespace std::literals::chrono_literals;
#endif
#endif // WTF_StdLibExtras_h