建档

source/Tool/Allocator.h

@@ -0,0 +1,151 @@
+#pragma once
+#include <limits>
+#include <cstddef>
+#include <utility>
+namespace memory
+{
+    /// \~chinese
+    /// @brief 内存分配器
+    class MemoryAllocator
+    {
+    public:
+        /// \~chinese
+        /// @brief 申请内存
+        virtual void *Alloc(size_t size) = 0;
+
+        /// \~chinese
+        /// @brief 释放内存
+        virtual void Free(void *ptr) = 0;
+    };
+
+    /// \~chinese
+    /// @brief 获取当前内存分配器
+    MemoryAllocator *GetAllocator();
+
+    /// \~chinese
+    /// @brief 设置当前内存分配器
+    void SetAllocator(MemoryAllocator *allocator);
+
+    /// \~chinese
+    /// @brief 使用当前内存分配器分配内存
+    inline void *Alloc(size_t size)
+    {
+        return memory::GetAllocator()->Alloc(size);
+    }
+
+    /// \~chinese
+    /// @brief 使用当前内存分配器释放内存
+    inline void Free(void *ptr)
+    {
+        memory::GetAllocator()->Free(ptr);
+    }
+
+} // namespace memory
+
+/// \~chinese
+/// @brief 分配器
+template <typename _Ty>
+class Allocator
+{
+public:
+    typedef _Ty value_type;
+    typedef _Ty *pointer;
+    typedef const _Ty *const_pointer;
+    typedef _Ty &reference;
+    typedef const _Ty &const_reference;
+
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+
+    template <class _Other>
+    struct rebind
+    {
+        using other = Allocator<_Other>;
+    };
+
+    Allocator() noexcept {}
+
+    Allocator(const Allocator &) noexcept = default;
+
+    template <class _Other>
+    Allocator(const Allocator<_Other> &) noexcept
+    {
+    }
+
+    inline _Ty *allocate(size_t count)
+    {
+        if (count > 0)
+        {
+            return static_cast<_Ty *>(memory::Alloc(sizeof(_Ty) * count));
+        }
+        return nullptr;
+    }
+
+    inline void *allocate(size_t count, const void *)
+    {
+        return allocate(count);
+    }
+
+    inline void deallocate(void *ptr, size_t count)
+    {
+        memory::Free(ptr /*, sizeof(_Ty) * count */);
+    }
+
+    template <typename _UTy, typename... _Args>
+    inline void construct(_UTy *const ptr, _Args &&...args)
+    {
+        ::new (const_cast<void *>(static_cast<const volatile void *>(ptr))) _Ty(std::forward<_Args>(args)...);
+    }
+
+    template <typename _UTy>
+    inline void destroy(_UTy *ptr)
+    {
+        ptr->~_UTy();
+    }
+
+    size_t max_size() const noexcept
+    {
+        return std::numeric_limits<size_t>::max() / sizeof(_Ty);
+    }
+
+    _Ty *address(_Ty &val) const noexcept
+    {
+        return std::addressof(val);
+    }
+
+    const _Ty *address(const _Ty &val) const noexcept
+    {
+        return std::addressof(val);
+    }
+};
+
+// Allocator<void>
+template <>
+class Allocator<void>
+{
+public:
+    using value_type = void;
+    typedef void *pointer;
+    typedef const void *const_pointer;
+
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+
+    template <class _Other>
+    struct rebind
+    {
+        using other = Allocator<_Other>;
+    };
+};
+
+template <class _Ty, class _Other>
+bool operator==(const Allocator<_Ty> &, const Allocator<_Other> &) noexcept
+{
+    return true;
+}
+
+template <class _Ty, class _Other>
+bool operator!=(const Allocator<_Ty> &, const Allocator<_Other> &) noexcept
+{
+    return false;
+}