heap_allocator.h

/*****************************************************/
/* lean Memory                  (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_MEMORY_HEAP_ALLOCATOR
#define LEAN_MEMORY_HEAP_ALLOCATOR

#include "../lean.h"
#include "../meta/strip.h"
#include "alignment.h"
#include "default_heap.h"

namespace lean
{
namespace memory
{

template<class Element, class Heap = default_heap, size_t Alignment = alignof(Element)>
class heap_allocator
{
public:
    typedef Heap heap_type;

    typedef typename strip_const<Element>::type value_type;

    typedef typename value_type* pointer;
    typedef typename value_type& reference;
    typedef typename const value_type* const_pointer;
    typedef typename const value_type& const_reference;

    typedef typename heap_type::size_type size_type;
    typedef ptrdiff_t difference_type;

    template<class Other>
    struct rebind
    {
        typedef heap_allocator<Other, Heap, Alignment> other;
    };
    
    LEAN_INLINE heap_allocator() { }
    template<class Other>
    LEAN_INLINE heap_allocator(const heap_allocator<Other, Heap, Alignment> &right) { }
    template<class Other>
    LEAN_INLINE heap_allocator& operator=(const heap_allocator<Other, Heap, Alignment> &right) { return *this; }
    
    LEAN_INLINE pointer allocate(size_type count)
    {
        return reinterpret_cast<pointer>( heap_type::allocate<Alignment>(count * sizeof(value_type)) );
    }
    LEAN_INLINE pointer allocate(size_type count, const void *)
    {
        return allocate(count);
    }
    LEAN_INLINE void deallocate(pointer ptr, size_type)
    {
        heap_type::free<Alignment>(ptr);
    }

    LEAN_INLINE void construct(pointer ptr, const value_type& value)
    {
        new(reinterpret_cast<void*>(ptr)) Element(value);
    }
    template<class Other>
    LEAN_INLINE void construct(pointer ptr, const Other& value)
    {
        new(reinterpret_cast<void*>(ptr)) Element(value);
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    LEAN_INLINE void construct(pointer ptr, value_type&& value)
    {
        new(reinterpret_cast<void*>(ptr)) Element(std::forward<value_type>(value));
    }
    template<class Other>
    LEAN_INLINE void construct(pointer ptr, Other&& value)
    {
        new(reinterpret_cast<void*>(ptr)) Element(std::forward<Other>(value));
    }
#endif

    LEAN_INLINE void destroy(pointer ptr)
    {
        ptr->~Element();
    }

    LEAN_INLINE pointer address(reference value) const
    {
        return reinterpret_cast<pointer>( &reinterpret_cast<char&>(value) );
    }
    LEAN_INLINE const_pointer address(const_reference value) const
    {
        return reinterpret_cast<const_pointer>( &reinterpret_cast<const char&>(value) );
    }

    LEAN_INLINE size_t max_size() const
    {
        size_t count = static_cast<size_t>(-1) / sizeof(Element);
        return (0 < count) ? count : 1;
    }
};

#ifndef DOXYGEN_SKIP_THIS

template<class Heap, size_t Alignment>
class heap_allocator<void, Heap, Alignment>
{
public:
    typedef Heap heap_type;

    typedef void value_type;

    typedef typename value_type* pointer;
    typedef typename const value_type* const_pointer;

    typedef typename heap_type::size_type size_type;
    typedef ptrdiff_t difference_type;

    template <class Other>
    struct rebind
    {
        typedef heap_allocator<Other, Heap, Alignment> other;
    };
    
    LEAN_INLINE heap_allocator() { }
    template <class Other>
    LEAN_INLINE heap_allocator(const heap_allocator<Other, Heap, Alignment> &right) { }
    template <class Other>
    LEAN_INLINE heap_allocator& operator=(const heap_allocator<Other, Heap, Alignment> &right) { return *this; }
};

#endif

template <class Element, class Heap, size_t Alignment, class Other>
LEAN_INLINE bool operator ==(const heap_allocator<Element, Heap, Alignment>&, const heap_allocator<Other, Heap, Alignment>&)
{
    return true;
}

template <class Element, class Heap, size_t Alignment, class Other>
LEAN_INLINE bool operator !=(const heap_allocator<Element, Heap, Alignment>&, const heap_allocator<Other, Heap, Alignment>&)
{
    return false;
}

} // namespace

using memory::heap_allocator;

} // namespace

#endif