Allocator.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Core/Meta.h"



#ifdef DEBUG
    #define new_                                new (__FILE__, __LINE__)
#else
    #define new_                                new
#endif

inline void* operator new(size_t size, const char* srcFile, int srcLine)    { mt_unused(srcFile); mt_unused(srcLine); return operator new(size); }
inline void* operator new[](size_t size, const char* srcFile, int srcLine)  { mt_unused(srcFile); mt_unused(srcLine); return operator new(size); }

namespace honey
{


template<class T>
T* alloc(szt count = 1)                         { return static_cast<T*>(operator new(sizeof(T)*count)); }
template<class T>
void free(T*& p)                                { if (!p) return; operator delete(p); p = nullptr; }
template<class T>
void free(T* const& p)                          { if (!p) return; operator delete(p); }

template<class T>
T* alignFloor(T* p, szt bytes)                  { return reinterpret_cast<T*>(intptr_t(p) & ~(bytes-1)); }
template<class T>
T* alignCeil(T* p, szt bytes)                   { return alignFloor(reinterpret_cast<T*>(intptr_t(p) + bytes-1), bytes); }

template<class T, class Alloc>
T* allocAligned(szt count, szt align_, Alloc&& a)
{
    int8* base = a.allocate(sizeof(sdt) + align_-1 + sizeof(T)*count);
    if (!base) return nullptr;
    int8* p = alignCeil(base+sizeof(sdt), align_);
    *reinterpret_cast<sdt*>(p-sizeof(sdt)) = p - base;
    return reinterpret_cast<T*>(p);
}
template<class T>
T* allocAligned(szt count, szt align)           { return allocAligned<T>(count, align, std::allocator<int8>()); }

template<class T, class Alloc>
void freeAligned(T* p, Alloc&& a)
{
    if (!p) return;
    int8* p_ = reinterpret_cast<int8*>(p);
    int8* base = p_ - *reinterpret_cast<sdt*>(p_ - sizeof(sdt));
    a.deallocate(base, 1);
}
template<class T>
void freeAligned(T* p)                          { freeAligned(p, std::allocator<int8>()); }


template<class T>
void delete_(T*& p)                             { delete p; p = nullptr; }
template<class T>
void delete_(T* const& p)                       { delete p; }

template<class T, class Alloc>
void delete_(T*& p, Alloc&& a)                  { if (!p) return; a.destroy(p); a.deallocate(p,1); p = nullptr; }
template<class T, class Alloc>
void delete_(T* const& p, Alloc&& a)            { if (!p) return; a.destroy(p); a.deallocate(p,1); }

template<class T>
void deleteArray(T*& p)                         { delete[] p; p = nullptr; }
template<class T>
void deleteArray(T* const& p)                   { delete[] p; }


template<template<class> class Subclass, class T>
class Allocator
{
public:
    typedef T           value_type;
    typedef T*          pointer;
    typedef T&          reference;
    typedef const T*    const_pointer;
    typedef const T&    const_reference;
    typedef szt         size_type;
    typedef sdt         difference_type;

    pointer address(reference x) const                      { return &x; }
    const_pointer address(const_reference x) const          { return &x; }
    size_type max_size() const                              { return std::numeric_limits<size_type>::max(); }
    template<class U, class... Args>
    void construct(U* p, Args&&... args)                    { new ((void*)p) U(forward<Args>(args)...); }
    template<class U>
    void destroy(U* p)                                      { p->~U(); }
    template<class U> struct rebind                         { typedef Subclass<U> other; };
    bool operator==(const Subclass<T>&) const               { return true; }
    bool operator!=(const Subclass<T>&) const               { return false; }

protected:
    Subclass<T>& subc()                                     { return static_cast<Subclass<T>&>(*this); }
    const Subclass<T>& subc() const                         { return static_cast<const Subclass<T>&>(*this); }
};

template<template<class> class Alloc>
class AllocatorObject
{
public:
    template<class T> using Allocator = Alloc<T>;

    void* operator new(szt size)                                            { return _alloc.allocate(size); }
    void* operator new(szt, void* ptr)                                      { return ptr; }
    void* operator new(szt size, const char* srcFile, int srcLine)          { return _alloc.allocate(size, srcFile, srcLine); }
    
    void* operator new[](szt size)                                          { return _alloc.allocate(size); }
    void* operator new[](szt, void* ptr)                                    { return ptr; }
    void* operator new[](szt size, const char* srcFile, int srcLine)        { return _alloc.allocate(size, srcFile, srcLine); }
    
    void operator delete(void* p)                                           { _alloc.deallocate(static_cast<int8*>(p), 1); }
    void operator delete[](void* p)                                         { _alloc.deallocate(static_cast<int8*>(p), 1); }

private:
    static Alloc<int8> _alloc;
};
template<template<class> class Alloc> Alloc<int8> AllocatorObject<Alloc>::_alloc;

template<class T, class = std::true_type>
struct DefaultAllocator                                                     { typedef std::allocator<T> type; };
template<class T>
struct DefaultAllocator<T[], std::true_type>                                { typedef std::allocator<T> type; };
template<class T>
struct DefaultAllocator<T, typename mt::True<typename T::template Allocator<T>>::type>
                                                                            { typedef typename T::template Allocator<T> type; };

template<class T, class Alloc = typename DefaultAllocator<T>::type>
struct finalize
{
    finalize(Alloc a = Alloc())                 : a(move(a)) {}
    void operator()(T*& p)                      { delete_(p,a); }
    void operator()(T* const& p)                { delete_(p,a); }
    Alloc a;
};
template<class T>
struct finalize<T[], std::allocator<T>>
{
    void operator()(T*& p)                      { deleteArray(p); }
    void operator()(T* const& p)                { deleteArray(p); }
};
template<>
struct finalize<void, std::allocator<void>>
{
    void operator()(void*& p)                   { free(p); }
    void operator()(void* const& p)             { free(p); }
};


}