allocator.h

Go to the documentation of this file.

 
#ifndef CPPCOMMON_MEMORY_ALLOCATOR_H
#define CPPCOMMON_MEMORY_ALLOCATOR_H
 
#include "memory.h"
 
namespace CppCommon {
 
 
template <typename T, class TMemoryManager, bool nothrow = false>
class Allocator
{
    template <typename U, class UMemoryManager, bool flag>
    friend class Allocator;
 
public:
    typedef T value_type;
    typedef T* pointer;
    typedef T& reference;
    typedef const T* const_pointer;
    typedef const T& const_reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
 
 
    explicit Allocator(TMemoryManager& manager) noexcept : _manager(manager) {}
    template <typename U>
    Allocator(const Allocator<U, TMemoryManager, nothrow>& alloc) noexcept : _manager(alloc._manager) {}
    Allocator(const Allocator& alloc) noexcept : _manager(alloc._manager) {}
    Allocator(Allocator&&) noexcept = default;
    ~Allocator() noexcept = default;
 
    template <typename U>
    Allocator& operator=(const Allocator<U, TMemoryManager, nothrow>& alloc) noexcept
    { _manager = alloc._manager; return *this; }
    Allocator& operator=(const Allocator& alloc) noexcept
    { _manager = alloc._manager; return *this; }
    Allocator& operator=(Allocator&&) noexcept = default;
 
 
    pointer address(reference x) const noexcept { return std::addressof(x); }
 
    const_pointer address(const_reference x) const noexcept { return std::addressof(x); }
 
 
    size_type max_size() const noexcept { return _manager.max_size(); }
 
 
    pointer allocate(size_type num, const void* hint = 0);
 
    void deallocate(pointer ptr, size_type num);
 
    void reset() { _manager.reset(); }
 
 
    template <typename U, class... Args>
    void construct(U* ptr, Args&&... args);
 
    template <typename U>
    void destroy(U* ptr);
 
 
    template <class... Args>
    T* Create(Args&&... args);
 
    void Release(T* ptr);
 
 
    template <class... Args>
    T* CreateArray(size_t length, Args&&... args);
 
    void ReleaseArray(T* ptr);
 
    template <typename TOther> struct rebind { using other = Allocator<TOther, TMemoryManager, nothrow>; };
 
private:
    TMemoryManager& _manager;
};
 
template <class TMemoryManager, bool nothrow>
class Allocator<void, TMemoryManager, nothrow>
{
public:
    typedef void value_type;
    typedef void* pointer;
    typedef const void* const_pointer;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
 
    Allocator(TMemoryManager& manager) noexcept : _manager(manager) {}
    template <typename U>
    Allocator(const Allocator<U, TMemoryManager, nothrow>& alloc) noexcept : _manager(alloc._manager) {}
    Allocator(Allocator&&) noexcept = default;
    ~Allocator() noexcept = default;
 
    template <typename U>
    Allocator& operator=(const Allocator<U, TMemoryManager, nothrow>& alloc) noexcept
    { _manager = alloc._manager; return *this; }
    Allocator& operator=(Allocator&&) noexcept = default;
 
    template <typename TOther> struct rebind { using other = Allocator<TOther, TMemoryManager, nothrow>; };
 
private:
    TMemoryManager _manager;
};
 
 
class DefaultMemoryManager
{
public:
    DefaultMemoryManager() noexcept : _allocated(0), _allocations(0) {}
    DefaultMemoryManager(const DefaultMemoryManager&) noexcept = default;
    DefaultMemoryManager(DefaultMemoryManager&&) noexcept = default;
    ~DefaultMemoryManager() noexcept { reset(); }
 
    DefaultMemoryManager& operator=(const DefaultMemoryManager&) noexcept = default;
    DefaultMemoryManager& operator=(DefaultMemoryManager&&) noexcept = default;
 
    size_t allocated() const noexcept { return _allocated; }
    size_t allocations() const noexcept { return _allocations; }
 
    size_t max_size() const noexcept { return std::numeric_limits<size_t>::max(); }
 
 
    void* malloc(size_t size, size_t alignment = alignof(std::max_align_t));
 
    void free(void* ptr, size_t size);
 
    void reset();
 
private:
    // Allocation statistics
    size_t _allocated;
    size_t _allocations;
};
 
template <typename T, bool nothrow = false>
using DefaultAllocator = Allocator<T, DefaultMemoryManager, nothrow>;
 
} // namespace CppCommon
 
#include "allocator.inl"
 
#endif // CPPCOMMON_MEMORY_ALLOCATOR_H