iterator_traits.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_ITERATOR_ITERATOR_TRAITS_HPP__
#define MSTL_CORE_ITERATOR_ITERATOR_TRAITS_HPP__

 
#include "MSTL/core/typeinfo/type_traits.hpp"
MSTL_BEGIN_NAMESPACE__


MSTL_BEGIN_INNER__
 
template <typename, typename = void>
struct iterator_traits_base {};
 
template <typename Iterator>
struct iterator_traits_base<Iterator,
    void_t<typename Iterator::iterator_category, typename Iterator::value_type,
    typename Iterator::difference_type, typename Iterator::pointer, typename Iterator::reference>>
{
    using iterator_category = typename Iterator::iterator_category;
    using value_type        = typename Iterator::value_type;
    using difference_type   = typename Iterator::difference_type;
    using pointer           = typename Iterator::pointer;
    using reference         = typename Iterator::reference;
};
 
MSTL_END_INNER__
 

template <typename Iterator>
struct iterator_traits : _INNER iterator_traits_base<Iterator> {};

template <typename T>
struct iterator_traits<T*> {
    static_assert(is_object<T>::value, "iterator traits requires object types.");
 
    using iterator_category = contiguous_iterator_tag; 
    using value_type        = remove_cv_t<T>;          
    using difference_type   = ptrdiff_t;               
    using pointer           = T*;                      
    using reference         = T&;                      
};

template <typename Iterator>
using iter_category_t   = typename iterator_traits<Iterator>::iterator_category;

template <typename Iterator>
using iter_value_t      = typename iterator_traits<Iterator>::value_type;

template <typename Iterator>
using iter_difference_t = typename iterator_traits<Iterator>::difference_type;

template <typename Iterator>
using iter_pointer_t    = typename iterator_traits<Iterator>::pointer;

template <typename Iterator>
using iter_reference_t  = typename iterator_traits<Iterator>::reference;
 

template <typename Iterator>
#ifdef MSTL_STANDARD_20__
requires is_pair_v<iter_value_t<Iterator>>
#endif
using iter_map_key_t = remove_const_t<typename iter_value_t<Iterator>::first_type>;

template <typename Iterator>
#ifdef MSTL_STANDARD_20__
requires is_pair_v<iter_value_t<Iterator>>
#endif
using iter_map_value_t = typename iter_value_t<Iterator>::second_type;
 // IteratorTraits


MSTL_BEGIN_INNER__

template <typename Ptr, typename Elem>
struct pointer_traits_base {
    using pointer = Ptr;  
    using element_type = Elem;  
    using difference_type = get_ptr_difference_t<Ptr>;  
    using reference = conditional_t<is_void<Elem>::value, char, Elem>&;  

    template <typename U>
    using rebind = typename get_rebind_type<Ptr, U>::type;

    MSTL_NODISCARD static constexpr pointer pointer_to(reference x)
        noexcept(noexcept(Ptr::pointer_to(x))) {
        return Ptr::pointer_to(x);
    }
};
 
template <typename, typename = void, typename = void>
struct __ptr_traits_extract {};
 
template <typename T, typename U>
struct __ptr_traits_extract<T, U, void_t<get_first_temp_para_t<T>>>
    : pointer_traits_base<T, typename get_first_temp_para<T>::type> {
};
 
template <typename T>
struct __ptr_traits_extract<T, void_t<typename T::element_type>, void>
    : pointer_traits_base<T, typename T::element_type> {
};
 
MSTL_END_INNER__
 

template <typename T>
struct pointer_traits : _INNER __ptr_traits_extract<T> {};
 

template <typename T>
struct pointer_traits<T*> {
    using pointer = T*;  
    using element_type = T;  
    using difference_type = ptrdiff_t;  
    using reference = conditional_t<is_void<T>::value, char, T>&;  

    template <typename U>
    using rebind = U*;

    MSTL_NODISCARD static constexpr pointer pointer_to(reference x) noexcept {
        return _MSTL addressof(x);
    }
};

template <typename Ptr, typename T>
using pointer_rebind = typename pointer_traits<Ptr>::template rebind<T>;

template <typename Ptr>
constexpr decltype(auto) ptr_const_cast(Ptr ptr) noexcept {
    using T = typename pointer_traits<Ptr>::element_type;
    using NonConst = remove_const_t<T>;
    using Dest = typename pointer_traits<Ptr>::template rebind<NonConst>;
 
    return pointer_traits<Dest>::pointer_to(const_cast<NonConst&>(*ptr));
}

template <typename T>
constexpr decltype(auto) ptr_const_cast(T* ptr) noexcept {
    return const_cast<remove_const_t<T>*>(ptr);
}
 

MSTL_BEGIN_INNER__
 
template <typename T>
constexpr T* __to_address(T* ptr) noexcept {
    static_assert(!is_function<T>::value, "not a function pointer");
    return ptr;
}
 
template <typename Ptr>
constexpr decltype(auto) __to_address(const Ptr& ptr) noexcept {
    return pointer_traits<Ptr>::to_address(ptr);
}
 
template <typename Ptr, typename... None, enable_if_t<!has_base<Ptr>::value, int> = 0>
constexpr decltype(auto) __to_address(const Ptr& ptr, None...) noexcept {
    return __to_address(ptr.operator->());
}
 
template <typename Ptr, typename... None, enable_if_t<has_base<Ptr>::value, int> = 0>
constexpr decltype(auto) __to_address(const Ptr& ptr, None...) noexcept {
    return __to_address(ptr.base().operator->());
}
 
MSTL_END_INNER__
 

template <typename T>
constexpr T* to_address(T* ptr) noexcept {
    return _INNER __to_address(ptr);
}

template <typename Ptr>
constexpr decltype(auto) to_address(const Ptr& ptr) noexcept {
    return _INNER __to_address(ptr);
}
 // PointerTraits


template <typename T, typename Dummy = void>
struct get_pointer_type {
    using type = typename T::value_type*;
};

template <typename T>
struct get_pointer_type<T, void_t<typename T::pointer>> {
    using type = typename T::pointer;
};
 

template <typename T, typename Dummy = void>
struct get_difference_type {
    using pointer = typename get_pointer_type<T>::type;
    using type = typename pointer_traits<pointer>::difference_type;
};

template <typename T>
struct get_difference_type<T, void_t<typename T::difference_type>> {
    using type = typename T::difference_type;
};
 

template <typename T, typename Dummy = void>
struct get_size_type {
    using type = make_unsigned_t<typename get_difference_type<T>::type>;
};

template <typename T>
struct get_size_type<T, void_t<typename T::size_type>> {
    using type = typename T::size_type;
};
 // AllocatorTraitsExtractors
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_ITERATOR_ITERATOR_TRAITS_HPP__