STLAllocator.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
JPH_NAMESPACE_BEGIN
 
template <class T> struct AllocatorHasReallocate { static constexpr bool sValue = false; };
 
#ifndef JPH_DISABLE_CUSTOM_ALLOCATOR
 
template <typename T>
class STLAllocator
{
public:
    using value_type = T;
 
    using pointer = T *;
    using const_pointer = const T *;
 
    using reference = T &;
    using const_reference = const T &;
 
    using size_type = size_t;
    using difference_type = ptrdiff_t;
 
    using is_always_equal = std::true_type;
 
    using propagate_on_container_move_assignment = std::true_type;
 
    inline                  STLAllocator() = default;
 
    template <typename T2>
    inline                  STLAllocator(const STLAllocator<T2> &) { }
 
    static constexpr bool   needs_aligned_allocate = alignof(T) > (JPH_CPU_ADDRESS_BITS == 32? 8 : 16);
 
    inline pointer          allocate(size_type inN)
    {
        if constexpr (needs_aligned_allocate)
            return pointer(AlignedAllocate(inN * sizeof(value_type), alignof(T)));
        else
            return pointer(Allocate(inN * sizeof(value_type)));
    }
 
    static constexpr bool   has_reallocate = std::is_trivially_copyable<T>() && !needs_aligned_allocate;
 
    template <bool has_reallocate_v = has_reallocate, typename = std::enable_if_t<has_reallocate_v>>
    inline pointer          reallocate(pointer inOldPointer, size_type inOldSize, size_type inNewSize)
    {
        JPH_ASSERT(inNewSize > 0); // Reallocating to zero size is implementation dependent, so we don't allow it
        return pointer(Reallocate(inOldPointer, inOldSize * sizeof(value_type), inNewSize * sizeof(value_type)));
    }
 
    inline void             deallocate(pointer inPointer, size_type)
    {
        if constexpr (needs_aligned_allocate)
            AlignedFree(inPointer);
        else
            Free(inPointer);
    }
 
    inline bool             operator == (const STLAllocator<T> &) const
    {
        return true;
    }
 
    inline bool             operator != (const STLAllocator<T> &) const
    {
        return false;
    }
 
    template <typename T2>
    struct rebind
    {
        using other = STLAllocator<T2>;
    };
};
 
template <class T> struct AllocatorHasReallocate<STLAllocator<T>> { static constexpr bool sValue = STLAllocator<T>::has_reallocate; };
 
#else
 
template <typename T> using STLAllocator = std::allocator<T>;
 
#endif // !JPH_DISABLE_CUSTOM_ALLOCATOR
 
// Declare STL containers that use our allocator
using String = std::basic_string<char, std::char_traits<char>, STLAllocator<char>>;
using IStringStream = std::basic_istringstream<char, std::char_traits<char>, STLAllocator<char>>;
 
JPH_NAMESPACE_END
 
#if (!defined(JPH_PLATFORM_WINDOWS) || defined(JPH_COMPILER_MINGW)) && !defined(JPH_DISABLE_CUSTOM_ALLOCATOR)
 
namespace std
{
    template <>
    struct hash<JPH::String>
    {
        inline size_t operator () (const JPH::String &inRHS) const
        {
            return hash<string_view> { } (inRHS);
        }
    };
}
 
#endif // (!JPH_PLATFORM_WINDOWS || JPH_COMPILER_MINGW) && !JPH_DISABLE_CUSTOM_ALLOCATOR