allocator_traits.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_ALLOCATOR_TRAITS_HPP__
#define NEFORCE_CORE_MEMORY_ALLOCATOR_TRAITS_HPP__

 
#include "NeForce/core/memory/construct.hpp"
#include "NeForce/core/numeric/numeric_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__


NEFORCE_BEGIN_INNER__

struct __allocator_traits_base {
    template <typename T, typename U, typename = void>
    struct alloc_rebind {
        using type = replace_first_para_t<U, T>;
    };

    template <typename T, typename U>
    struct alloc_rebind<T, U, void_t<typename T::template rebind<U>::other>> {
        using type = typename T::template rebind<U>::other;
    };

    template <typename T, typename U>
    using alloc_rebind_t = typename alloc_rebind<T, U>::type;
 
protected:
    template <typename T>
    using __pointer = typename T::pointer;
    template <typename T>
    using __c_pointer = typename T::const_pointer;
};
 
NEFORCE_END_INNER__

template <typename Alloc>
struct allocator_traits : inner::__allocator_traits_base {
    using allocator_type = Alloc;
    using value_type = typename Alloc::value_type;
    using pointer = detected_or_t<value_type*, __pointer, Alloc>;
 
private:
    template <template <typename> class Func, typename T, typename = void>
    struct real_ptr {
        using type = typename pointer_traits<pointer>::template rebind<T>;
    };
 
    template <template <typename> class Func, typename T>
    struct real_ptr<Func, T, void_t<Func<Alloc>>> {
        using type = Func<Alloc>;
    };
 
    template <typename, typename Ptr, typename = void>
    struct real_diff {
        using type = typename pointer_traits<Ptr>::difference_type;
    };
 
    template <typename AllocU, typename Ptr>
    struct real_diff<AllocU, Ptr, void_t<typename AllocU::difference_type>> {
        using type = typename AllocU::difference_type;
    };
 
    template <typename, typename Diff, typename = void>
    struct real_size : make_unsigned<Diff> {};
 
    template <typename AllocU, typename Diff>
    struct real_size<AllocU, Diff, void_t<typename AllocU::size_type>> {
        using type = typename AllocU::size_type;
    };
 
public:
    using const_pointer = typename real_ptr<__c_pointer, const value_type>::type; 
    using difference_type = typename real_diff<Alloc, pointer>::type;             
    using size_type = typename real_size<Alloc, difference_type>::type;           

    template <typename T>
    using rebind_alloc = alloc_rebind<Alloc, T>;

    template <typename T>
    using rebind_traits = allocator_traits<rebind_alloc<T>>;
 
private:
    template <typename T, typename... Args>
    static constexpr enable_if_t<has_construct_v<Alloc, T, Args...>>
    __construct_aux(Alloc& alloc, T* ptr,
                    Args&&... args) noexcept(noexcept(alloc.construct(ptr, _NEFORCE forward<Args>(args)...))) {
        alloc.construct(ptr, _NEFORCE forward<Args>(args)...);
    }
 
    template <typename T, typename... Args>
    static constexpr enable_if_t<
            conjunction_v<negation<has_construct<Alloc, T, Args...>>, is_constructible<T, Args...>>>
    __construct_aux(Alloc& /*unused*/, T* ptr,
                    Args&&... args) noexcept(_NEFORCE is_nothrow_constructible<T, Args...>::value) {
        _NEFORCE construct(ptr, _NEFORCE forward<Args>(args)...);
    }
 
    template <typename Alloc2, typename T>
    static constexpr auto __destroy_aux(Alloc2& alloc, T* ptr, int /*unused*/) noexcept(noexcept(alloc.destroy(ptr)))
            -> decltype(alloc.destroy(ptr)) {
        alloc.destroy(ptr);
    }
 
    template <typename Alloc2, typename T>
    static constexpr void __destroy_aux(Alloc2& /*unused*/, T* ptr, ...) noexcept(is_nothrow_destructible_v<T>) {
        _NEFORCE destroy(ptr);
    }
 
    template <typename Alloc2>
    static constexpr auto __max_size_aux(Alloc2& alloc, int /*unused*/) noexcept(noexcept(alloc.max_size()))
            -> decltype(alloc.max_size()) {
        return alloc.max_size();
    }
 
    template <typename Alloc2>
    static constexpr size_type __max_size_aux(Alloc2& /*unused*/, ...) noexcept {
        return _NEFORCE numeric_traits<size_type>::max() / sizeof(value_type);
    }
 
public:
    NEFORCE_NODISCARD static NEFORCE_CONSTEXPR20 pointer allocate(Alloc& alloc, size_type n) {
        return alloc.allocate(n);
    }

    static NEFORCE_CONSTEXPR20 void deallocate(Alloc& alloc, pointer ptr, size_type n) { alloc.deallocate(ptr, n); }

    template <typename T, typename... Args>
    static NEFORCE_CONSTEXPR20 void construct(Alloc& alloc, T* ptr, Args&&... args) noexcept(
            noexcept(allocator_traits::__construct_aux(alloc, ptr, _NEFORCE forward<Args>(args)...))) {
        allocator_traits::__construct_aux(alloc, ptr, _NEFORCE forward<Args>(args)...);
    }

    template <typename T>
    static NEFORCE_CONSTEXPR20 void destroy(Alloc& alloc,
                                            T* ptr) noexcept(noexcept(allocator_traits::__destroy_aux(alloc, ptr, 0))) {
        allocator_traits::__destroy_aux(alloc, ptr, 0);
    }

    static NEFORCE_CONSTEXPR20 size_type
    max_size(const Alloc& alloc) noexcept(noexcept(allocator_traits::__max_size_aux(alloc, 0))) {
        return allocator_traits::__max_size_aux(alloc, 0);
    }
};
 // AllocationTraits
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_MEMORY_ALLOCATOR_TRAITS_HPP__