from_allocator.hpp

Go to the documentation of this file.

 
#pragma once
 
#if defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL > 0
#error "_ITERATOR_DEBUG_LEVEL" must be defined as "0" for STL containers to be compatible with the ELDEN RING ABI.
#endif
 
#include <detail/preprocessor.hpp>
 
#include <bitset>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
 
// For std::terminate
#include <stdexcept>
 
namespace from {
namespace DLKR {
class DLAllocator {
public:
    virtual ~DLAllocator() = default;
 
    virtual int _allocator_id() = 0;
 
    virtual int _unused() {
        return -1;
    }
 
    virtual std::bitset<8> heap_flags() = 0;
 
    virtual size_t heap_capacity() = 0;
 
    virtual size_t heap_size() = 0;
 
    virtual size_t backing_heap_capacity() = 0;
 
    virtual size_t heap_allocation_count() = 0;
 
    virtual size_t msize(void* p) = 0;
 
    virtual void* allocate(size_t cb) = 0;
 
    virtual void* allocate_aligned(size_t cb, size_t alignment) = 0;
 
    virtual void* reallocate(void* p, size_t cb) = 0;
 
    virtual void* reallocate_aligned(void* p, size_t cb, size_t alignment) = 0;
 
    virtual void deallocate(void* p) = 0;
 
    virtual void _unsupported() {
        std::terminate();
    }
 
    virtual void* allocate_second(size_t cb) = 0;
 
    virtual void* allocate_second_aligned(size_t cb, size_t alignment) = 0;
 
    virtual void* reallocate_second(void* p, size_t cb) = 0;
 
    virtual void* reallocate_second_aligned(void* p, size_t cb,
        size_t alignment) = 0;
 
    virtual void deallocate_second(void* p) = 0;
 
    virtual bool _unknown_bool() {
        return false;
    }
 
    virtual bool belongs_to_first(void* p) = 0;
 
    virtual bool belongs_to_second(void* p) = 0;
 
    virtual void lock() {}
 
    virtual void unlock() {}
 
    virtual void* get_memory_block(void* p) = 0;
};
 
struct DLBackAllocator : public DLAllocator {};
} // namespace DLKR
 
struct default_allocator_tag {};
 
struct default_empty_base_allocator_tag {};
 
template <typename AllocatorTag>
class allocator_base;
 
template <typename T, typename AllocatorTag = default_allocator_tag>
class allocator : private allocator_base<AllocatorTag> {
    using base_type = allocator_base<AllocatorTag>;
    using proxy_type = DLKR::DLAllocator;
    using alloc_type = std::conditional_t<std::is_same_v<T, void>, char, T>;
 
    base_type& base() noexcept {
        return static_cast<base_type&>(*this);
    }
    const base_type& base() const noexcept {
        return static_cast<const base_type&>(*this);
    }
 
    proxy_type& proxy() noexcept {
        return this->base().get_allocator();
    }
    const proxy_type& proxy() const noexcept {
        return this->base().get_allocator();
    }
 
public:
    using value_type = T;
 
    using size_type = size_t;
 
    using difference_type = ptrdiff_t;
 
    using propagate_on_container_move_assignment = std::true_type;
 
    using is_always_equal = std::false_type;
 
    allocator() noexcept : base_type() {}
 
    template <typename U>
    allocator(const allocator<U>& other) noexcept : base_type(other.base()) {}
 
    allocator(DLKR::DLAllocator* dl_allocator) noexcept
        : base_type(dl_allocator) {}
 
    [[nodiscard]] T* allocate(size_type n) {
        return reinterpret_cast<T*>(this->proxy().allocate_aligned(
            n * sizeof(alloc_type), alignof(alloc_type)));
    }
 
    void deallocate(T* p, size_type n = 0) {
        this->proxy().deallocate((void*)p);
    }
 
    template <typename T1, typename T2>
    friend bool operator==(const allocator<T1>& lhs,
        const allocator<T2>& rhs) noexcept;
};
 
template <typename T1, typename T2>
bool operator==(const allocator<T1>& lhs, const allocator<T2>& rhs) noexcept {
    return std::addressof(lhs.proxy()) == std::addressof(rhs.proxy());
}
 
template <>
class allocator_base<default_allocator_tag> {
    DLKR::DLAllocator* allocator;
 
public:
    LIBERAPI allocator_base() noexcept;
 
    allocator_base(DLKR::DLAllocator* dl_allocator) noexcept
        : allocator(dl_allocator) {}
 
    DLKR::DLAllocator& get_allocator() const noexcept {
        return *this->allocator;
    }
};
 
template <>
class allocator_base<default_empty_base_allocator_tag> {
public:
    allocator_base() noexcept = default;
 
    allocator_base(DLKR::DLAllocator* dl_allocator) noexcept {}
 
    LIBERAPI DLKR::DLAllocator& get_allocator() const noexcept;
};
} // namespace from