iterator_traits.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ITERATOR_ITERATOR_TRAITS_HPP__
#define NEFORCE_CORE_ITERATOR_ITERATOR_TRAITS_HPP__

 
#include "NeForce/core/typeinfo/type_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__


NEFORCE_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;
};
 
NEFORCE_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 NEFORCE_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 NEFORCE_STANDARD_20
    requires is_pair_v<iter_value_t<Iterator>>
#endif
using iter_map_value_t = typename iter_value_t<Iterator>::second_type;
 // IteratorTraits


NEFORCE_BEGIN_INNER__
 
template <typename Ptr, enable_if_t<is_pointer<Ptr>::value, int> = 0>
static constexpr decltype(auto) __to_address(const Ptr& ptr) noexcept {
    static_assert(!is_function<Ptr>::value, "should not be a function pointer");
    return ptr;
}
 
template <typename Ptr, enable_if_t<!is_pointer<Ptr>::value && !has_base<Ptr>::value, int> = 0>
static constexpr decltype(auto) __to_address(const Ptr& ptr) noexcept {
    return inner::__to_address(ptr.operator->());
}
 
template <typename Ptr, enable_if_t<!is_pointer<Ptr>::value && has_base<Ptr>::value, int> = 0>
static constexpr decltype(auto) __to_address(const Ptr& ptr) noexcept {
    return ptr.base();
}
 

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;

    NEFORCE_NODISCARD static constexpr pointer pointer_to(reference x) noexcept(noexcept(Ptr::pointer_to(x))) {
        return Ptr::pointer_to(x);
    }

    NEFORCE_NODISCARD static constexpr decltype(auto) to_address(const Ptr& ptr) noexcept {
        return inner::__to_address(ptr);
    }
};
 
template <typename, typename = void, typename = void>
struct pointer_traits_extract {};
 
template <typename T, typename U>
struct pointer_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 pointer_traits_extract<T, void_t<typename T::element_type>, void>
: pointer_traits_base<T, typename T::element_type> {};
 
NEFORCE_END_INNER__
 

template <typename T>
struct pointer_traits : inner::pointer_traits_extract<T> {
    NEFORCE_NODISCARD static constexpr decltype(auto) to_address(const T& ptr) noexcept {
        return inner::__to_address(ptr);
    }
};
 

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*;

    NEFORCE_NODISCARD static constexpr pointer pointer_to(reference ref) noexcept { return _NEFORCE addressof(ref); }
 
    NEFORCE_NODISCARD static constexpr pointer to_address(pointer ptr) noexcept {
        static_assert(!is_function<T>::value, "should not be a function pointer");
        return ptr;
    }
};

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);
}

template <typename Ptr>
constexpr decltype(auto) to_address(const Ptr& ptr) noexcept {
    return pointer_traits<Ptr>::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
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ITERATOR_ITERATOR_TRAITS_HPP__