allocator.h

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <new>
 
#include "utils/move.h"
 
namespace bmb {
 
class PrimitiveAllocator {
public:
    template <typename T>
    [[nodiscard]]
    T* allocate(size_t n) {
        return static_cast<T*>(operator new(n * sizeof(T)));
    }
 
    template <typename T>
    void deallocate(T* ptr, size_t) noexcept {
        operator delete(ptr);
    }
 
    bool operator==(const PrimitiveAllocator&) const { return true; };
};
 
template <typename Alloc>
class AllocatorTraits {
public:
    using allocator_type = Alloc;
 
    template <typename T, typename... Args>
    static void construct(Alloc& alloc, T* ptr, Args&&... args) {
        // Use allocator if can
        if constexpr (requires {
                          alloc.construct(ptr, forward<Args>(args)...);
                      }) {
            alloc.construct(ptr, forward<Args>(args)...);
        } else {
            new (ptr) T(forward<Args>(args)...);
        }
    }
 
    template <typename T>
    static void destroy(Alloc& alloc, T* ptr) {
        // Use allocator if can
        if constexpr (requires { alloc.destroy(ptr); }) {
            alloc.destroy(ptr);
        } else ptr->~T();
    }
 
    template <typename T>
    [[nodiscard]]
    static T* allocate(Alloc& alloc, size_t n) {
        return alloc.template allocate<T>(n);
    }
 
    template <typename T>
    static void deallocate(Alloc& alloc, T* ptr, size_t n) {
        alloc.deallocate(ptr, n);
    }
};
 
}  // namespace bmb