allocator.h

Go to the documentation of this file.

 
#pragma once
 
#include "./memory_resource.h"
#include "./throw_bad_alloc.h"
 
#include <functional>
 
namespace emlabcpp::pmr
{
 
template < typename T >
class allocator
{
public:
        using value_type = T;
 
        template < typename U >
        allocator( allocator< U > const& other )
          : resource_( other.resource_ )
        {
        }
 
        allocator( pmr::memory_resource& src )
          : resource_( src )
        {
        }
 
        T* allocate( std::size_t const n )
        {
                void* const res = resource_.get().allocate( n * sizeof( T ), alignof( T ) );
                if ( res == nullptr )
                        throw_bad_alloc();
                return reinterpret_cast< T* >( res );
        }
 
        void deallocate( T* const p, std::size_t const n ) const
        {
                result const res = resource_.get().deallocate(
                    reinterpret_cast< void* >( p ), n * sizeof( T ), alignof( T ) );
                if ( res == result::ERROR )
                        throw_bad_alloc();
        }
 
        friend constexpr bool operator==( allocator const& lh, allocator const& rh )
        {
                return lh.resource_.get().is_equal( rh.resource_.get() );
        }
 
        pmr::memory_resource& get_resource()
        {
                return resource_;
        }
 
        template < typename U >
        friend class allocator;
 
private:
        std::reference_wrapper< pmr::memory_resource > resource_;
};
 
}  // namespace emlabcpp::pmr