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 <cstddef>
#include <cstdint>
#include <utility>
 
namespace from {
namespace DLKR {
class DLAllocator {
public:
    virtual ~DLAllocator() = default;
 
    virtual int get_allocator_id() = 0;
 
    virtual int _unk0x10() {
        return -1;
    }
 
    virtual int& get_heap_flags(int& flags) = 0;
 
    virtual size_t get_heap_capacity() = 0;
 
    virtual size_t get_heap_size() = 0;
 
    virtual size_t get_heap_backing_capacity() = 0;
 
    virtual size_t get_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 _unk0x70() {}
 
    virtual void* allocate2(size_t cb) {
        return this->allocate(cb);
    }
 
    virtual void* allocate2_aligned(size_t cb, size_t alignment) {
        return this->allocate_aligned(cb, alignment);
    }
 
    virtual void* reallocate2(void* p, size_t cb) {
        return this->reallocate(p, cb);
    }
 
    virtual void* reallocate2_aligned(void* p, size_t cb, size_t alignment) {
        return this->reallocate_aligned(p, cb, alignment);
    }
 
    virtual void deallocate2(void* p) {
        this->deallocate(p);
    }
 
    virtual bool _unk0xA0() {
        return false;
    }
 
    virtual bool check_owned(void* p) = 0;
 
    virtual bool _unk0xB0(std::nullptr_t) {
        return false;
    }
 
    virtual void lock() = 0;
 
    virtual void unlock() = 0;
 
    virtual void* get_block(void* p) = 0;
};
 
LIBERAPI DLAllocator& get_dlallocator_of(const void* p) noexcept;
 
LIBERAPI DLAllocator& get_base_allocator() noexcept;
} // namespace DLKR
 
template <typename T>
class allocator {
    using base_type = DLKR::DLAllocator;
    using alloc_type = std::conditional_t<std::is_same_v<T, void>, char, T>;
 
    base_type* base;
 
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(&DLKR::get_base_allocator()) {}
 
    allocator(const allocator& other) noexcept : base(other.base) {}
 
    template <typename U>
    allocator(const allocator<U>& other) noexcept : base(other.base) {}
 
    explicit allocator(base_type* allocator_base) noexcept
        : base(allocator_base) {}
 
    [[nodiscard]] T* allocate(size_type n) {
        return reinterpret_cast<T*>(this->base->allocate_aligned(
            n * sizeof(alloc_type), alignof(alloc_type)));
    }
 
    void deallocate(T* p, size_type n = 0) {
        this->base->deallocate(static_cast<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 lhs.base == rhs.base;
}
 
template <typename T>
from::allocator<T> get_allocator_of(const T* p) noexcept {
    return from::allocator<T>(
        &DLKR::get_dlallocator_of(static_cast<const void*>(p)));
}
} // namespace from