array.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_CONTAINER_ARRAY_HPP__
#define NEFORCE_CORE_CONTAINER_ARRAY_HPP__

 
#include "NeForce/core/algorithm/compare.hpp"
#include "NeForce/core/algorithm/shift.hpp"
#include "NeForce/core/interface/icollector.hpp"
#include "NeForce/core/interface/iiterator.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <bool IsConst, size_t Size, typename Array>
struct array_iterator : iiterator<array_iterator<IsConst, Size, Array>> {
public:
    using container_type = Array;                                     
    using value_type = typename container_type::value_type;           
    using size_type = typename container_type::size_type;             
    using difference_type = typename container_type::difference_type; 
    using iterator_category = contiguous_iterator_tag;                
    using reference = conditional_t<IsConst, typename container_type::const_reference,
                                    typename container_type::reference>; 
    using pointer = conditional_t<IsConst, typename container_type::const_pointer,
                                  typename container_type::pointer>; 
 
private:
    pointer current_ = nullptr;                 
    const container_type* container_ = nullptr; 
 
public:
    constexpr array_iterator() noexcept = default;
    NEFORCE_CONSTEXPR20 ~array_iterator() = default;
 
    constexpr array_iterator(const array_iterator&) noexcept = default;
    constexpr array_iterator& operator=(const array_iterator&) noexcept = default;
    constexpr array_iterator(array_iterator&&) noexcept = default;
    constexpr array_iterator& operator=(array_iterator&&) noexcept = default;

    constexpr array_iterator(pointer ptr, const container_type* vec) noexcept :
    current_(ptr),
    container_(vec) {}

    NEFORCE_NODISCARD constexpr reference dereference() const noexcept {
        NEFORCE_DEBUG_VERIFY(current_ && container_, "Attempting to dereference on a null pointer");
        NEFORCE_DEBUG_VERIFY(current_ >= container_->data() && current_ < container_->data() + Size,
                             "Attempting to dereference out of boundary");
        return *current_;
    }

    constexpr void increment() noexcept {
        NEFORCE_DEBUG_VERIFY(current_ && container_, "Attempting to increment a null pointer");
        NEFORCE_DEBUG_VERIFY(current_ < container_->data() + Size, "Attempting to increment out of boundary");
        ++current_;
    }

    constexpr void decrement() noexcept {
        NEFORCE_DEBUG_VERIFY(current_ && container_, "Attempting to decrement a null pointer");
        NEFORCE_DEBUG_VERIFY(current_ > container_->data(), "Attempting to decrement out of boundary");
        --current_;
    }

    constexpr void advance(difference_type off) noexcept {
        NEFORCE_DEBUG_VERIFY((current_ && container_) || off == 0, "Attempting to advance a null pointer");
        NEFORCE_DEBUG_VERIFY(current_ + off >= container_->data() && current_ + off <= container_->data() + Size,
                             "Attempting to advance out of boundary");
        current_ += off;
    }

    NEFORCE_NODISCARD constexpr difference_type distance_to(const array_iterator& other) const noexcept {
        NEFORCE_DEBUG_VERIFY(container_ == other.container_, "Attempting to distance to a different container");
        return static_cast<difference_type>(current_ - other.current_);
    }

    NEFORCE_NODISCARD constexpr reference operator[](const difference_type off) const noexcept {
        return *(*this + off);
    }

    NEFORCE_NODISCARD constexpr bool equal_to(const array_iterator& rhs) const noexcept {
        NEFORCE_DEBUG_VERIFY(container_ == rhs.container_, "Attempting to equal to a different container");
        return current_ == rhs.current_;
    }

    NEFORCE_NODISCARD constexpr bool less_than(const array_iterator& rhs) const noexcept {
        NEFORCE_DEBUG_VERIFY(container_ == rhs.container_, "Attempting to less than a different container");
        return current_ < rhs.current_;
    }

    NEFORCE_NODISCARD constexpr pointer base() const noexcept { return current_; }

    NEFORCE_NODISCARD constexpr const container_type* container() const noexcept { return container_; }
};
 

template <typename T, size_t Size>
class array : public icollector<array<T, Size>> {
    static_assert(is_object_v<T>, "array only containers of object types.");
 
public:
    using value_type = T;
    using pointer = T*;
    using reference = T&;
    using const_pointer = const T*;
    using const_reference = const T&;
    using size_type = size_t;
    using difference_type = ptrdiff_t;
 
    using iterator = array_iterator<false, Size, array>;                      
    using const_iterator = array_iterator<true, Size, array>;                 
    using reverse_iterator = _NEFORCE reverse_iterator<iterator>;             
    using const_reverse_iterator = _NEFORCE reverse_iterator<const_iterator>; 
 
private:
    T array_[Size]; 
 
public:
    constexpr array() noexcept = default;
    NEFORCE_CONSTEXPR20 ~array() noexcept = default;
 
    constexpr array(const array&) noexcept = default;
    constexpr array& operator=(const array&) noexcept = default;
    constexpr array(array&&) noexcept = default;
    constexpr array& operator=(array&&) noexcept = default;

    constexpr array(std::initializer_list<T> ilist) noexcept {
        size_t size = ilist.size() < Size ? ilist.size() : Size;
        _NEFORCE copy(ilist.begin(), ilist.begin() + size, array_);
    }

    NEFORCE_NODISCARD constexpr iterator begin() noexcept { return iterator(array_, this); }

    NEFORCE_NODISCARD constexpr iterator end() noexcept { return iterator(array_ + Size, this); }

    NEFORCE_NODISCARD constexpr const_iterator begin() const noexcept { return const_iterator(array_, this); }

    NEFORCE_NODISCARD constexpr const_iterator end() const noexcept { return const_iterator(array_ + Size, this); }

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

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

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

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

    NEFORCE_NODISCARD constexpr const_iterator cbegin() const noexcept { return const_iterator(array_, this); }

    NEFORCE_NODISCARD constexpr const_iterator cend() const noexcept { return const_iterator(array_ + Size, this); }

    NEFORCE_NODISCARD constexpr const_reverse_iterator crbegin() const noexcept {
        return const_reverse_iterator(cend());
    }

    NEFORCE_NODISCARD constexpr const_reverse_iterator crend() const noexcept {
        return const_reverse_iterator(cbegin());
    }

    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr size_type size() const noexcept {
        return Size;
    }

    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr size_type max_size() const noexcept {
        return Size;
    }

    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr bool empty() const noexcept {
        return false;
    }

    NEFORCE_NODISCARD constexpr reference at(size_type position) noexcept {
        NEFORCE_DEBUG_VERIFY(position < Size, "array subscript out of range");
        return array_[position];
    }

    NEFORCE_NODISCARD constexpr const_reference at(size_type position) const noexcept {
        NEFORCE_DEBUG_VERIFY(position < Size, "array subscript out of range");
        return array_[position];
    }

    NEFORCE_NODISCARD constexpr reference operator[](size_type position) noexcept {
        NEFORCE_DEBUG_VERIFY(position < Size, "array subscript out of range");
        return array_[position];
    }

    NEFORCE_NODISCARD constexpr const_reference operator[](size_type position) const noexcept {
        NEFORCE_DEBUG_VERIFY(position < Size, "array subscript out of range");
        return array_[position];
    }

    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr reference front() noexcept { return array_[0]; }
    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr const_reference front() const noexcept { return array_[0]; }
    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr reference back() noexcept { return array_[Size - 1]; }
    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr const_reference back() const noexcept { return array_[Size - 1]; }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr T* data() noexcept { return array_; }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr const T* data() const noexcept {
        return array_;
    }

    constexpr void fill(const T& value) { _NEFORCE fill_n(array_, Size, value); }

    constexpr void swap(array& other) noexcept(is_nothrow_swappable_v<T>) { _NEFORCE swap(array_, other.array_); }

    NEFORCE_NODISCARD constexpr bool equal_to(const array& rhs) const noexcept {
        return _NEFORCE equal(this->cbegin(), this->cend(), rhs.cbegin());
    }

    NEFORCE_NODISCARD constexpr bool less_than(const array& rhs) const noexcept {
        return _NEFORCE lexicographical_compare(this->cbegin(), this->cend(), rhs.cbegin(), rhs.cend());
    }
};
 
struct empty_array_element_tag {
    constexpr explicit empty_array_element_tag() noexcept = default;
};

template <typename T>
class array<T, 0> : public icollector<array<T, 0>> {
    static_assert(is_object_v<T>, "array only containers of object types.");
 
public:
    using value_type = T;
    using pointer = T*;
    using reference = T&;
    using const_pointer = const T*;
    using const_reference = const T&;
    using size_type = size_t;
    using difference_type = ptrdiff_t;
 
    using iterator = array_iterator<false, 0, array>;
    using const_iterator = array_iterator<true, 0, array>;
    using reverse_iterator = _NEFORCE reverse_iterator<iterator>;
    using const_reverse_iterator = _NEFORCE reverse_iterator<const_iterator>;
 
private:
    using placeholder =
            conditional_t<disjunction_v<is_default_constructible<T>, is_implicitly_default_constructible<T>>, T,
                          empty_array_element_tag>;
 
    placeholder array_[1]{placeholder{}};
 
public:
    constexpr array() noexcept = default;
    NEFORCE_CONSTEXPR20 ~array() noexcept = default;
 
    constexpr array(const array& /*unused*/) noexcept {}
    // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
    constexpr array& operator=(const array& /*unused*/) noexcept { return *this; }
    constexpr array(array&& /*unused*/) noexcept {}
    constexpr array& operator=(array&& /*unused*/) noexcept { return *this; }
 
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr iterator begin() noexcept {
        return iterator{};
    }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr iterator end() noexcept {
        return iterator{};
    }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr const_iterator begin() const noexcept {
        return const_iterator{};
    }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr const_iterator end() const noexcept {
        return const_iterator{};
    }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr const_reverse_iterator
    rbegin() const noexcept {
        return const_reverse_iterator(end());
    }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr const_reverse_iterator
    rend() const noexcept {
        return const_reverse_iterator(begin());
    }
    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr const_iterator cbegin() const noexcept { return begin(); }
    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr const_iterator cend() const noexcept { return end(); }
    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }
    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr const_reverse_iterator crend() const noexcept { return rend(); }
 
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr size_type size() const noexcept {
        return 0;
    }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr size_type max_size() const noexcept {
        return 0;
    }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr bool empty() const noexcept {
        return true;
    }
 
    NEFORCE_NODISCARD reference at(size_type /*unused*/) {
        NEFORCE_THROW_EXCEPTION(iterator_exception("array empty."));
        return array_[0];
    }
 
    NEFORCE_NODISCARD const_reference at(size_type /*unused*/) const {
        NEFORCE_THROW_EXCEPTION(iterator_exception("array empty."));
        return array_[0];
    }
 
    NEFORCE_NODISCARD reference operator[](size_type /*unused*/) {
        NEFORCE_THROW_EXCEPTION(iterator_exception("array index out of range"));
        return *data();
    }
    NEFORCE_NODISCARD const_reference operator[](size_type /*unused*/) const {
        NEFORCE_THROW_EXCEPTION(iterator_exception("array index out of range"));
        return *data();
    }
 
    NEFORCE_NODISCARD reference front() {
        NEFORCE_THROW_EXCEPTION(iterator_exception("array empty."));
        return *data();
    }
    NEFORCE_NODISCARD const_reference front() const {
        NEFORCE_THROW_EXCEPTION(iterator_exception("array empty."));
        return *data();
    }
 
    NEFORCE_NODISCARD reference back() {
        NEFORCE_THROW_EXCEPTION(iterator_exception("array empty."));
        return *data();
    }
 
    NEFORCE_NODISCARD const_reference back() const {
        NEFORCE_THROW_EXCEPTION(iterator_exception("array empty."));
        return *data();
    }
 
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr T* data() noexcept { return nullptr; }
    NEFORCE_NODISCARD NEFORCE_CONST_FUNCTION NEFORCE_ALWAYS_INLINE constexpr const T* data() const noexcept {
        return nullptr;
    }
 
    NEFORCE_ALWAYS_INLINE constexpr void fill(const T& /*unused*/) {}
    NEFORCE_ALWAYS_INLINE constexpr void swap(array& /*unused*/) noexcept {}
 
    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr bool equal_to(const array& /*unused*/) const noexcept {
        return true;
    }
    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr bool less_than(const array& /*unused*/) const noexcept {
        return false;
    }
};
 
#ifdef NEFORCE_STANDARD_17
NEFORCE_BEGIN_INNER__
template <typename First, typename... Rest>
struct __array_same {
    static_assert(conjunction_v<is_same<First, Rest>...>, "array types mismatch.");
    using type = First;
};
NEFORCE_END_INNER__
 
template <typename First, typename... Rest>
array(First, Rest...) -> array<typename inner::__array_same<First, Rest...>::type, 1 + sizeof...(Rest)>;
#endif
 

template <size_t Idx, typename T, size_t Size>
NEFORCE_NODISCARD constexpr T& get(array<T, Size>& arr) noexcept {
    static_assert(Idx < Size, "array index out of bounds");
    return arr[Idx];
}

template <size_t Idx, typename T, size_t Size>
NEFORCE_NODISCARD constexpr const T& get(const array<T, Size>& arr) noexcept {
    static_assert(Idx < Size, "array index out of bounds");
    return arr[Idx];
}

template <size_t Idx, typename T, size_t Size>
NEFORCE_NODISCARD constexpr T&& get(array<T, Size>&& arr) noexcept {
    static_assert(Idx < Size, "array index out of bounds");
    return _NEFORCE move(arr[Idx]);
}

template <size_t Idx, typename T, size_t Size>
NEFORCE_NODISCARD constexpr const T&& get(const array<T, Size>&& arr) noexcept {
    static_assert(Idx < Size, "array index out of bounds");
    return _NEFORCE move(arr[Idx]);
}
 // Array


template <typename T, size_t Size>
struct tuple_size<array<T, Size>> : integral_constant<size_t, Size> {};
 
#define __NEFORCE_BUILD_ARRAY_TUPLE_SIZE(CV) \
    template <typename T, size_t Size>       \
    struct tuple_size<array<T, Size> CV> : integral_constant<size_t, Size> {};
NEFORCE_MACRO_RANGES_CV(__NEFORCE_BUILD_ARRAY_TUPLE_SIZE)
#undef __NEFORCE_BUILD_ARRAY_TUPLE_SIZE

template <size_t Idx, typename T, size_t Size>
struct tuple_element<Idx, array<T, Size>> {
    static_assert(Idx < Size, "array index is in range");
    using type = T;
};
 
template <typename T, size_t Size>
NEFORCE_INLINE17 constexpr size_t tuple_size_v<array<T, Size>> = Size; 
 
template <typename T, size_t Size>
NEFORCE_INLINE17 constexpr size_t tuple_size_v<const array<T, Size>> = Size; 
 // Tuple
 
NEFORCE_END_NAMESPACE__
 
#ifdef NEFORCE_STANDARD_17
#    include <utility>
namespace std {
    template <typename T, size_t Size>
    struct tuple_size<_NEFORCE array<T, Size>> : _NEFORCE integral_constant<_NEFORCE size_t, Size> {};
 
    template <size_t Idx, typename T, size_t Size>
    struct tuple_element<Idx, _NEFORCE array<T, Size>> {
        using type = _NEFORCE tuple_element_t<Idx, _NEFORCE array<T, Size>>;
    };
} // namespace std
#endif
 
#endif // NEFORCE_CORE_CONTAINER_ARRAY_HPP__