uniqueallocator.h

#ifndef _UNIQUEALLOCATOR_H_
#define _UNIQUEALLOCATOR_H_

#include <memory>

// The following template comes from
//     https://howardhinnant.github.io/allocator_boilerplate.html

namespace slidingbuffer {

template <typename T> class UniqueAllocator
{
public:
    using value_type    = T;      

    // not required, unless used
    UniqueAllocator() noexcept {}
    
    template <class U> UniqueAllocator(UniqueAllocator<U> const&) noexcept {}

    // Use pointer if pointer is not a value_type*
    value_type* allocate(std::size_t n)
    {
        return static_cast<value_type*>(::operator new (n*sizeof(value_type)));
    }
    
    // Use pointer if pointer is not a value_type*
    void deallocate(value_type* p, std::size_t n) noexcept
    {
        ::operator delete(p);
    }

    template <class P> inline void delete_if_ptr (P* const& p) { delete(p); }

    template <class P> inline void delete_if_ptr (P const&) { }

    template <class U> void destroy(U* p) noexcept
    {
        delete_if_ptr(*p);
        p->~U();
    }
};

template <class T, class U> bool
operator==(UniqueAllocator<T> const&, UniqueAllocator<U> const&) noexcept
{
    return true;
};

template <class T, class U> bool
operator!=(UniqueAllocator<T> const& x, UniqueAllocator<U> const& y) noexcept
{
    return !(x == y);
};

} // end namespace slidingbuffer

#endif