allocator_traits.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_MEMORY_ALLOCATOR_TRAITS_HPP__
#define MSTL_CORE_MEMORY_ALLOCATOR_TRAITS_HPP__

 
#include "MSTL/core/memory/construct.hpp"
#include "MSTL/core/numeric/numeric_traits.hpp"
MSTL_BEGIN_NAMESPACE__


MSTL_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;
};
 
MSTL_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, _MSTL forward<Args>(args)...))) {
        alloc.construct(ptr, _MSTL 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&, T* ptr, Args&&... args)
    noexcept(_MSTL is_nothrow_constructible<T, Args...>::value) {
        _MSTL construct(ptr, _MSTL forward<Args>(args)...);
    }
 
    template <typename Alloc2, typename T>
    static constexpr auto __destroy_aux(Alloc2& alloc, T* ptr, int)
    noexcept(noexcept(alloc.destroy(ptr))) -> decltype(alloc.destroy(ptr)) {
        alloc.destroy(ptr);
    }
 
    template <typename Alloc2, typename T>
    static constexpr void __destroy_aux(Alloc2&, T* ptr, ...)
    noexcept(is_nothrow_destructible_v<T>) {
        _MSTL destroy(ptr);
    }
 
    template <typename Alloc2>
    static constexpr auto __max_size_aux(Alloc2& alloc, int)
    noexcept(noexcept(alloc.max_size()))
    -> decltype(alloc.max_size()) {
        return alloc.max_size();
    }
 
    template <typename Alloc2>
    static constexpr size_type __max_size_aux(Alloc2&, ...) noexcept {
        return _MSTL numeric_traits<size_type>::max() / sizeof(value_type);
    }
 
public:
    MSTL_NODISCARD static MSTL_CONSTEXPR20 pointer allocate(Alloc& alloc, size_type n) {
        return alloc.allocate(n);
    }

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

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

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

    static MSTL_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
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_MEMORY_ALLOCATOR_TRAITS_HPP__