memory_view.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_MEMORY_VIEW_HPP__
#define NEFORCE_CORE_MEMORY_MEMORY_VIEW_HPP__

 
#include "NeForce/core/container/array.hpp"
#include "NeForce/core/exception/breakpoint.hpp"
#include "NeForce/core/iterator/normal_iterator.hpp"
#include "NeForce/core/iterator/reverse_iterator.hpp"
#include "NeForce/core/numeric/numeric_traits.hpp"
#include "NeForce/core/utility/compressed_pair.hpp"
NEFORCE_BEGIN_NAMESPACE__


NEFORCE_INLINE17 constexpr size_t dynamic_extent = numeric_traits<size_t>::max();

NEFORCE_BEGIN_INNER__

template <size_t Extent>
struct extent_storage {
    constexpr extent_storage() noexcept = default;
 
    constexpr extent_storage(const extent_storage&) noexcept = default;
    constexpr extent_storage& operator=(const extent_storage&) noexcept = default;
 
    constexpr extent_storage(extent_storage&&) noexcept = default;
    constexpr extent_storage& operator=(extent_storage&&) noexcept = default;
 
    constexpr extent_storage(size_t) noexcept {}
    static constexpr size_t extent() noexcept { return Extent; }
};

template <>
struct extent_storage<dynamic_extent> {
private:
    size_t extent_value_ = 0;
 
public:
    constexpr extent_storage() noexcept = default;
 
    constexpr extent_storage(const extent_storage&) noexcept = default;
    constexpr extent_storage& operator=(const extent_storage&) noexcept = default;
 
    constexpr extent_storage(extent_storage&&) noexcept = default;
    constexpr extent_storage& operator=(extent_storage&&) noexcept = default;
 
    constexpr extent_storage(const size_t extent_value) noexcept :
    extent_value_(extent_value) {}
 
    constexpr size_t extent() const noexcept { return extent_value_; }
};
 
NEFORCE_END_INNER__
 

template <typename Element, size_t Extent = dynamic_extent>
class memory_view {
public:
    using element_type = Element; 
 
    using value_type = remove_cv_t<Element>;                      
    using size_type = size_t;                                     
    using difference_type = ptrdiff_t;                            
    using pointer = Element*;                                     
    using const_pointer = const Element*;                         
    using reference = element_type&;                              
    using const_reference = const element_type&;                  
    using iterator = normal_iterator<pointer>;                    
    using reverse_iterator = _NEFORCE reverse_iterator<iterator>; 
 
private:
    template <typename U, size_t ArrayExtent, enable_if_t<Extent == dynamic_extent || ArrayExtent == Extent, int> = 0>
    using is_compatible_array = is_array_convertible<Element, U>;
 
    template <typename Ref>
    using is_compatible_ref = is_array_convertible<Element, remove_reference_t<Ref>>;

    compressed_pair<inner::extent_storage<Extent>, pointer> extent_pair_;
 
    template <typename U, size_t OE>
    friend class memory_view;
 
private:
    template <size_t, size_t Count, enable_if_t<Count != dynamic_extent, int> = 0>
    static constexpr size_t view_extent() noexcept {
        return Count;
    }
 
    template <size_t Offset, size_t Count, enable_if_t<Count == dynamic_extent && Extent != dynamic_extent, int> = 0>
    static constexpr size_t view_extent() noexcept {
        return Extent - Offset;
    }
 
    template <size_t, size_t Count, enable_if_t<Count == dynamic_extent && Extent == dynamic_extent, int> = 0>
    static constexpr size_t view_extent() noexcept {
        return dynamic_extent;
    }
 
    template <size_t UE = Extent, enable_if_t<UE != dynamic_extent, int> = 0>
    static NEFORCE_ALWAYS_INLINE constexpr void check_extend(const size_t count) noexcept {
        NEFORCE_CONSTEXPR_ASSERT(count == Extent);
    }
    template <size_t UE = Extent, enable_if_t<UE == dynamic_extent, int> = 0>
    static NEFORCE_ALWAYS_INLINE constexpr void check_extend(const size_t) noexcept {}
 
    template <size_t UE = Extent, enable_if_t<UE != dynamic_extent, int> = 0>
    NEFORCE_ALWAYS_INLINE constexpr void check_count(const size_t Count) const noexcept {
        static_assert(Count <= Extent, "COunt must less than Extend");
    }
    template <size_t UE = Extent, enable_if_t<UE == dynamic_extent, int> = 0>
    NEFORCE_ALWAYS_INLINE constexpr void check_count(const size_t Count) const noexcept {
        NEFORCE_CONSTEXPR_ASSERT(Count <= size())
    }
 
    template <size_t Offset, size_t Count, enable_if_t<Count == dynamic_extent, int> = 0>
    constexpr decltype(auto) view_aux() const noexcept {
        using view = memory_view<element_type, view_extent<Offset, Count>()>;
        return view{data() + Offset, size() - Offset};
    }
    template <size_t Offset, size_t Count, enable_if_t<Count != dynamic_extent, int> = 0>
    constexpr decltype(auto) view_aux() const noexcept {
        using view = memory_view<element_type, view_extent<Offset, Count>()>;
        memory_view::check_count<Extent>(Count);
        memory_view::check_count<Extent>(Count + Offset);
        return view{data() + Offset, Count};
    }
 
public:
    constexpr memory_view() noexcept
#ifdef NEFORCE_STANDARD_20
        requires((Extent + 1u) <= 1u)
#endif
    :
    extent_pair_(exact_arg_construct_tag{}, 0, nullptr) {
    }

    template <typename Iterator, enable_if_t<is_cot_iter_v<Iterator>, int> = 0>
#ifdef NEFORCE_STANDARD_20
        requires is_compatible_ref<iter_reference_t<Iterator>>::value
#endif
    constexpr
#ifdef NEFORCE_STANDARD_20
            explicit(Extent != dynamic_extent)
#endif
                    memory_view(Iterator first, size_type count) noexcept :
    extent_pair_(exact_arg_construct_tag{}, count, _NEFORCE to_address(first)) {
        memory_view::check_extend<Extent>(count);
    }

    template <typename Iterator, enable_if_t<is_cot_iter_v<Iterator>, int> = 0>
#ifdef NEFORCE_STANDARD_20
        requires is_compatible_ref<iter_reference_t<Iterator>>::value
#endif
    constexpr
#ifdef NEFORCE_STANDARD_20
            explicit(Extent != dynamic_extent)
#endif
                    memory_view(Iterator first, Iterator last) noexcept(noexcept(_NEFORCE distance(first, last))) :
    extent_pair_(exact_arg_construct_tag{}, static_cast<size_type>(last - first), _NEFORCE to_address(first)) {
        memory_view::check_extend<Extent>(_NEFORCE distance(first, last));
    }

    template <size_t AE>
#ifdef NEFORCE_STANDARD_20
        requires(Extent == dynamic_extent || AE == Extent)
#endif
    constexpr memory_view(type_identity_t<element_type> (&arr)[AE]) noexcept :
    memory_view(static_cast<pointer>(arr), AE) {
    }

    template <typename U, size_t AE>
#ifdef NEFORCE_STANDARD_20
        requires is_compatible_array<U, AE>::value
#endif
    constexpr memory_view(array<U, AE>& arr) noexcept :
    memory_view(static_cast<pointer>(arr.data()), AE) {
    }

    template <typename U, size_t AE>
#ifdef NEFORCE_STANDARD_20
        requires is_compatible_array<const U, AE>::value
#endif
    constexpr memory_view(const array<U, AE>& arr) noexcept :
    memory_view(static_cast<pointer>(arr.data()), AE) {
    }

    constexpr memory_view(const memory_view& other) noexcept = default;

    template <typename U, size_t OE>
#ifdef NEFORCE_STANDARD_20
        requires(Extent == dynamic_extent || OE == dynamic_extent || Extent == OE) && is_array_convertible_v<Element, U>
#endif
    constexpr
#ifdef NEFORCE_STANDARD_20
            explicit(Extent != dynamic_extent && OE == dynamic_extent)
#endif
                    memory_view(const memory_view<U, OE>& other) noexcept :
    extent_pair_(exact_arg_construct_tag{}, other.extent_pair_.get_base(),
                 static_cast<pointer>(other.extent_pair_.value)) {
        memory_view::check_extend<Extent>(other.size());
    }

    constexpr memory_view& operator=(const memory_view& other) noexcept = default;

    NEFORCE_CONSTEXPR20 ~memory_view() noexcept = default;

    NEFORCE_NODISCARD constexpr size_type size() const noexcept { return extent_pair_.get_base().extent(); }

    NEFORCE_NODISCARD constexpr size_type size_bytes() const noexcept { return size() * sizeof(element_type); }

    NEFORCE_NODISCARD constexpr bool empty() const noexcept { return size() == 0; }

    NEFORCE_NODISCARD constexpr reference front() const noexcept {
        NEFORCE_CONSTEXPR_ASSERT(!empty());
        return *extent_pair_.value;
    }

    NEFORCE_NODISCARD constexpr reference back() const noexcept {
        NEFORCE_CONSTEXPR_ASSERT(!empty());
        return *(extent_pair_.value + (size() - 1));
    }

    NEFORCE_NODISCARD constexpr reference operator[](size_type index) const noexcept {
        NEFORCE_CONSTEXPR_ASSERT(index < size());
        return *(extent_pair_.value + index);
    }

    NEFORCE_NODISCARD constexpr pointer data() const noexcept { return extent_pair_.value; }

    NEFORCE_NODISCARD constexpr iterator begin() const noexcept { return iterator(extent_pair_.value); }

    NEFORCE_NODISCARD constexpr iterator end() const noexcept { return iterator(extent_pair_.value + size()); }

    NEFORCE_NODISCARD constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }

    NEFORCE_NODISCARD constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }

    template <size_t Count>
    constexpr memory_view<element_type, Count> first() const noexcept {
        memory_view::check_count<Extent>(Count);
        using view = memory_view<element_type, Count>;
        return view{data(), Count};
    }

    constexpr memory_view<element_type> first(size_type count) const noexcept {
        NEFORCE_CONSTEXPR_ASSERT(count <= size());
        return {data(), count};
    }

    template <size_t Count>
    constexpr memory_view<element_type, Count> last() const noexcept {
        memory_view::check_count<Extent>(Count);
        using view = memory_view<element_type, Count>;
        return view{data() + (size() - Count), Count};
    }

    constexpr memory_view<element_type> last(size_type count) const noexcept {
        NEFORCE_CONSTEXPR_ASSERT(count <= size());
        return {data() + (size() - count), count};
    }

    template <size_t Offset, size_t Count = dynamic_extent>
    constexpr auto view() const noexcept -> memory_view<element_type, view_extent<Offset, Count>()> {
        memory_view::check_count<Extent>(Offset);
        return this->template view_aux<Offset, Count>();
    }

    constexpr memory_view<element_type> view(size_type offset, size_type count = dynamic_extent) const noexcept {
        NEFORCE_CONSTEXPR_ASSERT(offset <= size());
        if (count == dynamic_extent) {
            count = size() - offset;
        } else {
            NEFORCE_CONSTEXPR_ASSERT(count <= size());
            NEFORCE_CONSTEXPR_ASSERT(offset + count <= size());
        }
        return {data() + offset, count};
    }
};
 
#ifdef NEFORCE_STANDARD_17
template <typename T, size_t ArrayExtent>
memory_view(T (&)[ArrayExtent]) -> memory_view<T, ArrayExtent>;
 
template <typename T, size_t ArrayExtent>
memory_view(array<T, ArrayExtent>&) -> memory_view<T, ArrayExtent>;
 
template <typename T, size_t ArrayExtent>
memory_view(const array<T, ArrayExtent>&) -> memory_view<const T, ArrayExtent>;
 
#    ifdef NEFORCE_STANDARD_20
template <contiguous_iterator Iter, typename End>
#    else
template <typename Iter, typename End>
#    endif
memory_view(Iter, End) -> memory_view<remove_reference_t<iter_reference_t<Iter>>>;
#endif

using byte_view = memory_view<byte_t>;

using cbyte_view = memory_view<const byte_t>;
 // MemoryView
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_MEMORY_MEMORY_VIEW_HPP__