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
 
#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;
 
    inline                  STLAllocator() = default;
 
    template <typename T2>
    inline                  STLAllocator(const STLAllocator<T2> &) { }
 
    inline pointer          allocate(size_type inN)
    {
        if constexpr (alignof(T) > (JPH_CPU_ADDRESS_BITS == 32? 8 : 16))
            return pointer(AlignedAllocate(inN * sizeof(value_type), alignof(T)));
        else
            return pointer(Allocate(inN * sizeof(value_type)));
    }
 
    inline void             deallocate(pointer inPointer, size_type)
    {
        if constexpr (alignof(T) > (JPH_CPU_ADDRESS_BITS == 32? 8 : 16))
            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>;
    };
};
 
#else
 
template <typename T> using STLAllocator = std::allocator<T>;
 
#endif // !JPH_DISABLE_CUSTOM_ALLOCATOR
 
// Declare STL containers that use our allocator
template <class T> using Array = std::vector<T, STLAllocator<T>>;
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