type_allocator.h

Go to the documentation of this file.

#pragma once
 
#include "../utility/empty_base.h"
#include "../utility/meta.h"
#include "../utility/source_location.h"
 
#include "type_allocator_fwd.h"
 
#include <memory>
#include <type_traits>
 
namespace ktl
{
    template<typename T, typename Alloc>
    class type_allocator
    {
    private:
        static_assert(detail::has_no_value_type_v<Alloc>, "Building on top of typed allocators is not allowed. Use allocators without a type");
        static_assert(!std::is_const_v<T>, "Using an allocator of const T is ill-formed");
        static_assert(!std::is_copy_constructible_v<Alloc> || std::is_nothrow_copy_constructible_v<Alloc>, "Using a throwing copy constructor is ill-formed");
        static_assert(!std::is_move_constructible_v<Alloc> || std::is_nothrow_move_constructible_v<Alloc>, "Using a throwing move constructor is ill-formed");
        static_assert(!std::is_copy_assignable_v<Alloc> || std::is_nothrow_copy_assignable_v<Alloc>, "Using throwing copy assignment is ill-formed");
        static_assert(!std::is_move_assignable_v<Alloc> || std::is_nothrow_move_assignable_v<Alloc>, "Using throwing move assignment is ill-formed");
 
        template<typename U, typename A>
        friend class type_allocator;
 
    public:
        typedef T value_type;
        typedef typename detail::get_size_type_t<Alloc> size_type;
        typedef std::false_type is_always_equal;
 
        template<typename U>
        struct rebind
        {
            typedef type_allocator<U, Alloc> other;
        };
 
        type_allocator() = default;
 
        template<typename... Args,
            typename = std::enable_if_t<
            std::is_constructible_v<Alloc, Args...>>>
        explicit type_allocator(Args&&... alloc)
            noexcept(std::is_nothrow_constructible_v<T, Args...>) :
            m_Alloc(std::forward<Args>(alloc)...) {}
 
        type_allocator(const type_allocator&) = default;
 
        // Move construction is essentially forbidden for STL allocators
        // A al(std::move(a)); a == al
        // https://en.cppreference.com/w/cpp/named_req/Allocator
        type_allocator(type_allocator&& other)
            noexcept(std::is_nothrow_copy_constructible_v<Alloc>) :
            m_Alloc(other.m_Alloc) {}
 
        template<typename U>
        type_allocator(const type_allocator<U, Alloc>& other)
            noexcept(std::is_nothrow_constructible_v<Alloc, const type_allocator<U, Alloc>&>) :
            m_Alloc(other.m_Alloc) {}
 
        // Move construction is essentially forbidden for STL allocators
        // https://en.cppreference.com/w/cpp/named_req/Allocator
        template<typename U>
        type_allocator(type_allocator<U, Alloc>&& other)
            noexcept(std::is_nothrow_constructible_v<Alloc, type_allocator<U, Alloc>&&>) :
            m_Alloc(other.m_Alloc) {}
 
        type_allocator& operator=(const type_allocator&) = default;
 
        // Move construction is essentially forbidden for STL allocators
        // https://en.cppreference.com/w/cpp/named_req/Allocator
        type_allocator& operator=(type_allocator&& rhs)
            noexcept(std::is_nothrow_copy_assignable_v<Alloc>)
        {
            m_Alloc = rhs.m_Alloc;
 
            return *this;
        }
 
#pragma region Allocation
        value_type* allocate(size_t n, const source_location source = KTL_SOURCE())
            noexcept(noexcept(m_Alloc.allocate(n)))
        {
            return reinterpret_cast<value_type*>(detail::allocate(m_Alloc, sizeof(value_type) * n, source));
        }
 
        void deallocate(value_type* p, size_t n)
            noexcept(noexcept(m_Alloc.deallocate(p, n)))
        {
            m_Alloc.deallocate(p, sizeof(value_type) * n);
        }
#pragma endregion
 
#pragma region Construction
        template<typename... Args>
        typename std::enable_if<detail::has_construct_v<Alloc, value_type*, Args...>, void>::type
        construct(value_type* p, Args&&... args)
            noexcept(detail::has_nothrow_construct_v<Alloc, value_type*, Args...>)
        {
            m_Alloc.construct(p, std::forward<Args>(args)...);
        }
 
        template<typename A = Alloc>
        typename std::enable_if<detail::has_destroy_v<A, value_type*>, void>::type
        destroy(value_type* p)
            noexcept(detail::has_nothrow_destroy_v<Alloc, value_type*>)
        {
            m_Alloc.destroy(p);
        }
#pragma endregion
 
#pragma region Utility
        template<typename A = Alloc>
        typename std::enable_if<detail::has_max_size_v<A>, size_type>::type
        max_size() const
            noexcept(detail::has_nothrow_max_size_v<A>)
        {
            return m_Alloc.max_size() / sizeof(T);
        }
 
        template<typename A = Alloc>
        typename std::enable_if<detail::has_owns_v<A>, bool>::type
        owns(value_type* p) const
            noexcept(detail::has_nothrow_owns_v<A>)
        {
            return m_Alloc.owns(p);
        }
#pragma endregion
 
        Alloc& get_allocator() noexcept
        {
            return m_Alloc;
        }
 
        const Alloc& get_allocator() const noexcept
        {
            return m_Alloc;
        }
 
    private:
        KTL_EMPTY_BASE Alloc m_Alloc;
    };
 
    template<typename T, typename U, typename Alloc>
    bool operator==(const type_allocator<T, Alloc>& lhs, const type_allocator<U, Alloc>& rhs)
        noexcept(detail::has_nothrow_equal_v<Alloc>)
    {
        return lhs.get_allocator() == rhs.get_allocator();
    }
 
    template<typename T, typename U, typename Alloc>
    bool operator!=(const type_allocator<T, Alloc>& lhs, const type_allocator<U, Alloc>& rhs)
        noexcept(detail::has_nothrow_not_equal_v<Alloc>)
    {
        return lhs.get_allocator() != rhs.get_allocator();
    }
}