#pragma once /* * Created by Brett on 06/02/24. * Licensed under GNU General Public License V3.0 * See LICENSE file for license detail */ #ifndef BLT_RANGES_H #define BLT_RANGES_H #include <blt/std/types.h> #include <blt/meta/meta.h> #include <blt/meta/iterator.h> #include <type_traits> #include <iterator> #include <memory> #include <utility> #include <limits> namespace blt { template<typename T> struct enumerate_item { blt::size_t index; T value; }; template<typename Iter> class enumerate_iterator_base { public: explicit enumerate_iterator_base(Iter iter, blt::size_t place = 0): iter(std::move(iter)), index(place) {} enumerate_item<blt::meta::deref_return_t<Iter>> operator*() const { return {index, *this->iter}; } friend bool operator==(const enumerate_iterator_base& a, const enumerate_iterator_base& b) { return a.iter == b.iter; } friend bool operator!=(const enumerate_iterator_base& a, const enumerate_iterator_base& b) { return a.iter != b.iter; } auto base() const { return iter; } auto get_index() const { return index; } protected: Iter iter; blt::size_t index; }; template<typename Iter> class enumerate_forward_iterator : public enumerate_iterator_base<Iter> { public: using enumerate_iterator_base<Iter>::enumerate_iterator_base; enumerate_forward_iterator& operator++() { ++this->iter; ++this->index; return *this; } enumerate_forward_iterator operator++(int) { auto tmp = *this; ++*this; return tmp; } }; template<typename Iter> class enumerate_bidirectional_iterator : public enumerate_forward_iterator<Iter> { public: using enumerate_forward_iterator<Iter>::enumerate_forward_iterator; enumerate_bidirectional_iterator& operator--() { --this->iter; --this->index; return *this; } enumerate_bidirectional_iterator operator--(int) { auto tmp = *this; --*this; return tmp; } }; template<typename Iter, typename = std::void_t<>> class enumerate_wrapper; template<typename Iter> class enumerate_wrapper<Iter, std::enable_if_t<blt::meta::is_forward_iterator<Iter>, std::void_t<std::forward_iterator_tag>>> : public enumerate_forward_iterator<Iter> { public: using iterator_category = std::forward_iterator_tag; using value_type = enumerate_item<blt::meta::deref_return_t<Iter>>; using difference_type = typename std::iterator_traits<Iter>::difference_type; using pointer = value_type; using reference = value_type; using iterator_type = Iter; using enumerate_forward_iterator<Iter>::enumerate_forward_iterator; }; template<typename Iter> class enumerate_wrapper<Iter, std::enable_if_t<blt::meta::is_bidirectional_or_better<Iter>, std::void_t<std::bidirectional_iterator_tag>>> : public enumerate_bidirectional_iterator<Iter> { public: using iterator_category = typename std::iterator_traits<Iter>::iterator_category; using value_type = enumerate_item<blt::meta::deref_return_t<Iter>>; using difference_type = typename std::iterator_traits<Iter>::difference_type; using pointer = value_type; using reference = value_type; using iterator_type = Iter; using enumerate_bidirectional_iterator<Iter>::enumerate_bidirectional_iterator; }; template<typename Iter, typename IterWrapper> class enumerator_base { public: explicit enumerator_base(Iter begin, Iter end): begin_(std::move(begin)), end_(std::move(end)) {} explicit enumerator_base(IterWrapper begin, IterWrapper end): begin_(std::move(begin)), end_(std::move(end)) {} auto begin() { return begin_; } auto end() { return end_; } protected: IterWrapper begin_; IterWrapper end_; }; template<typename Iter, typename IterWrapper, typename Reverse> class enumerator_reversible : public enumerator_base<Iter, IterWrapper> { public: explicit enumerator_reversible(Iter begin, Iter end, blt::size_t container_size): enumerator_base<Iter, IterWrapper>(std::move(begin), std::move(end)), container_size(container_size) {} explicit enumerator_reversible(Iter begin, Iter end, blt::size_t begin_index, blt::size_t end_index): enumerator_base<Iter, IterWrapper>(IterWrapper(std::move(begin), begin_index), IterWrapper(std::move(end), end_index)), container_size(std::abs(static_cast<blt::ptrdiff_t>(end_index) - static_cast<blt::ptrdiff_t>(begin_index))) {} auto rev() { return Reverse{this->end_.base(), this->begin_.base(), this->container_size, 0ul}; } protected: blt::size_t container_size; }; template<typename Iter, typename = std::void_t<>> class enumerator; template<typename Iter, typename = std::void_t<>> class enumerator_rev; template<typename Iter> class enumerator<Iter, std::enable_if_t<blt::meta::is_forward_iterator<Iter>, std::void_t<std::forward_iterator_tag>>> : public enumerator_base<Iter, enumerate_wrapper<Iter>> { public: using enumerator_base<Iter, enumerate_wrapper<Iter>>::enumerator_base; }; template<typename Iter> class enumerator<Iter, std::enable_if_t<blt::meta::is_bidirectional_iterator<Iter>, std::void_t<std::bidirectional_iterator_tag>>> : public enumerator_reversible<Iter, enumerate_wrapper<Iter>, enumerator_rev<Iter>> { public: using enumerator_reversible<Iter, enumerate_wrapper<Iter>, enumerator_rev<Iter>>::enumerator_reversible; }; template<typename Iter> class enumerator<Iter, std::enable_if_t<blt::meta::is_random_access_iterator<Iter>, std::void_t<std::random_access_iterator_tag>>> : public enumerator_reversible<Iter, enumerate_wrapper<Iter>, enumerator_rev<Iter>> { public: using enumerator_reversible<Iter, enumerate_wrapper<Iter>, enumerator_rev<Iter>>::enumerator_reversible; }; template<typename Iter> class enumerator_rev<Iter, std::enable_if_t<blt::meta::is_bidirectional_iterator<Iter>, std::void_t<std::bidirectional_iterator_tag>>> : public enumerator_reversible<Iter, std::reverse_iterator<enumerate_wrapper<Iter>>, enumerator<Iter>> { public: using enumerator_reversible<Iter, std::reverse_iterator<enumerate_wrapper<Iter>>, enumerator<Iter>>::enumerator_reversible; }; template<typename Iter> class enumerator_rev<Iter, std::enable_if_t<blt::meta::is_random_access_iterator<Iter>, std::void_t<std::random_access_iterator_tag>>> : public enumerator_reversible<Iter, std::reverse_iterator<enumerate_wrapper<Iter>>, enumerator<Iter>> { public: using enumerator_reversible<Iter, std::reverse_iterator<enumerate_wrapper<Iter>>, enumerator<Iter>>::enumerator_reversible; }; template<typename Iter> enumerator(Iter, Iter) -> enumerator<Iter>; template<typename Iter> enumerator(Iter, Iter, blt::size_t) -> enumerator<Iter>; template<typename Iter> enumerator(Iter, Iter, blt::size_t, blt::size_t) -> enumerator<Iter>; template<typename T> static inline auto enumerate(const T& container) { return enumerator{container.begin(), container.end(), container.size()}; } template<typename T, blt::size_t size> static inline auto enumerate(const T(& container)[size]) { return enumerator{&container[0], &container[size], size}; } template<typename T, blt::size_t size> static inline auto enumerate(T(& container)[size]) { return enumerator{&container[0], &container[size], size}; } template<typename T> static inline auto enumerate(T& container) { return enumerator{container.begin(), container.end(), container.size()}; } template<typename T> static inline auto enumerate(T&& container) { return enumerator{container.begin(), container.end(), container.size()}; } namespace itr { template<typename Begin, typename End> class itr_container { public: itr_container(Begin&& begin, End&& end): begin_(std::forward<Begin>(begin)), end_(std::forward<End>(end)) {} Begin begin() { return begin_; } End end() { return end_; } private: Begin begin_; End end_; }; // TODO: cleanup! all of this! add support for reversing template<typename C1_TYPE, typename C2_TYPE> class pair_iterator { public: using c1_ref = blt::meta::deref_return_t<C1_TYPE>; using c2_ref = blt::meta::deref_return_t<C2_TYPE>; using iterator_category = std::forward_iterator_tag; using value_type = std::pair<c1_ref, c2_ref>; using difference_type = blt::ptrdiff_t; using pointer = void*; using reference = value_type&; using const_reference = const value_type&; explicit pair_iterator(C1_TYPE c1, C2_TYPE c2): current_c1_iter(c1), current_c2_iter(c2) {} pair_iterator& operator++() { ++current_c1_iter; ++current_c2_iter; return *this; } bool operator==(pair_iterator other) const { return current_c1_iter == other.current_c1_iter && current_c2_iter == other.current_c2_iter; } bool operator!=(pair_iterator other) const { return current_c1_iter != other.current_c1_iter || current_c2_iter != other.current_c2_iter; } value_type operator*() const { return {*current_c1_iter, *current_c2_iter}; }; value_type operator*() { return {*current_c1_iter, *current_c2_iter}; }; private: C1_TYPE current_c1_iter; C2_TYPE current_c2_iter; }; } template<typename Begin, typename End> static inline auto iterate(Begin&& begin, End&& end) { return itr::itr_container<Begin, End>{std::forward<Begin>(begin), std::forward<End>(end)}; } template<typename Begin, typename End> static inline auto reverse_iterate(Begin&& begin, End&& end) { return itr::itr_container{std::reverse_iterator(std::forward<Begin>(end)), std::reverse_iterator(std::forward<End>(begin))}; } template<typename C1_ITER, typename C2_ITER, template<typename, typename> typename iterator = itr::pair_iterator> class pair_enumerator { public: explicit pair_enumerator(C1_ITER c1_begin, C1_ITER c1_end, C2_ITER c2_begin, C2_ITER c2_end): begin_(std::move(c1_begin), std::move(c2_begin)), end_(std::move(c1_end), std::move(c2_end)) { auto size_c1 = c1_end - c1_begin; auto size_c2 = c2_end - c2_begin; if (size_c1 != size_c2) throw std::runtime_error("Iterator sizes don't match!"); } iterator<C1_ITER, C2_ITER> begin() { return begin_; } iterator<C1_ITER, C2_ITER> end() { return end_; } private: iterator<C1_ITER, C2_ITER> begin_; iterator<C1_ITER, C2_ITER> end_; }; template<typename T, typename G> static inline auto in_pairs(const T& container1, const G& container2) { return pair_enumerator{container1.begin(), container1.end(), container2.begin(), container2.end()}; } template<typename T, typename G> static inline auto in_pairs(T& container1, G& container2) { return pair_enumerator{container1.begin(), container1.end(), container2.begin(), container2.end()}; } template<typename T, typename G, blt::size_t size> static inline auto in_pairs(const T(& container1)[size], const G(& container2)[size]) { return pair_enumerator{&container1[0], &container1[size], &container2[0], &container2[size]}; } template<typename T, typename G, blt::size_t size> static inline auto in_pairs(T(& container1)[size], G(& container2)[size]) { return pair_enumerator{&container1[0], &container1[size], &container2[0], &container2[size]}; } template<typename T, typename G> static inline auto in_pairs(T&& container1, G&& container2) { return pair_enumerator{container1.begin(), container1.end(), container2.begin(), container2.end()}; } template<typename T> struct range { public: struct range_itr { public: using iterator_category = std::bidirectional_iterator_tag; using difference_type = T; using value_type = T; using pointer = T*; using reference = T&; private: T current; bool forward; public: explicit range_itr(T current, bool forward): current(current), forward(forward) {} value_type operator*() const { return current; } value_type operator->() { return current; } range_itr& operator++() { if (forward) current++; else current--; return *this; } range_itr& operator--() { if (forward) current--; else current++; return *this; } friend bool operator==(const range_itr& a, const range_itr& b) { return a.current == b.current; } friend bool operator!=(const range_itr& a, const range_itr& b) { return a.current != b.current; } }; private: T _begin; T _end; T offset = 0; public: range(T begin, T end): _begin(begin), _end(end), offset(end < begin ? 1 : 0) {} range_itr begin() { return range_itr(_begin - offset, offset == 0); } range_itr end() { // not sure if i like this return range_itr(_end - offset, offset == 0); } }; template<typename I> class itr_offset { private: I begin_; I end_; public: template<typename T> itr_offset(I begin, I end, T offset): begin_(begin), end_(end) { for (T t = 0; t < offset; t++) ++begin_; } template<typename C, typename T> itr_offset(C& container, T offset): begin_(container.begin()), end_(container.end()) { for (T t = 0; t < offset; t++) ++begin_; } auto begin() { return begin_; } auto end() { return end_; } }; template<typename C, typename T> itr_offset(C, T) -> itr_offset<typename C::iterator>; inline constexpr std::size_t dynamic_extent = std::numeric_limits<std::size_t>::max(); template<typename T, std::size_t extent = dynamic_extent> class span; // https://codereview.stackexchange.com/questions/217814/c17-span-implementation namespace span_detail { // detect specializations of span template<class T> struct is_span : std::false_type { }; template<class T, std::size_t N> struct is_span<span<T, N>> : std::true_type { }; template<class T> inline constexpr bool is_span_v = is_span<T>::value; // detect specializations of std::array template<class T> struct is_array : std::false_type { }; template<class T, std::size_t N> struct is_array<std::array<T, N>> : std::true_type { }; template<class T> inline constexpr bool is_array_v = is_array<T>::value; // detect container template<class C, class = void> struct is_cont : std::false_type { }; template<class C> struct is_cont<C, std::void_t< std::enable_if_t<!is_span_v<C>>, std::enable_if_t<!is_array_v<C>>, std::enable_if_t<!std::is_array_v<C>>, decltype(data(std::declval<C>())), decltype(size(std::declval<C>())) >> : std::true_type { }; template<class C> inline constexpr bool is_cont_v = is_cont<C>::value; } template<typename T, std::size_t extent> class span { public: using element_type = T; using value_type = std::remove_cv_t<T>; using size_type = blt::size_t; using difference_type = std::ptrdiff_t; using pointer = T*; using const_pointer = const T*; using reference = T&; using const_reference = const T&; using iterator = T*; using const_iterator = const T*; using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>; private: size_type size_; pointer data_; public: constexpr span() noexcept: size_(0), data_(nullptr) {} constexpr span(T* data, size_type count): size_(count), data_(data) {} template<class It, std::size_t SIZE, typename std::enable_if_t<extent != dynamic_extent && SIZE == extent, bool> = true> constexpr explicit span(It first, size_type count): size_(count), data_(&*first) {} template<class It, std::size_t SIZE, typename std::enable_if_t<extent == dynamic_extent && SIZE == extent, bool> = true> constexpr span(It first, size_type count): size_(count), data_(&*first) {} template<class It, class End, std::size_t SIZE, typename std::enable_if_t<extent != dynamic_extent && SIZE == extent, bool> = true> constexpr explicit span(It first, End last): size_(&*last - &*first), data_(&*first) {} template<class It, class End, std::size_t SIZE, typename std::enable_if_t<extent == dynamic_extent && SIZE == extent, bool> = true> constexpr span(It first, End last): size_(&*last - &*first), data_(&*first) {} template<std::size_t N, typename std::enable_if_t<(N == dynamic_extent || N == extent) && (std::is_convertible_v<std::remove_pointer_t<decltype( std::data(std::declval<T(&)[N]>()))>(*)[], T(*)[]>), bool> = true> constexpr span(element_type (& arr)[N]) noexcept: size_{N}, data_{arr} // NOLINT {} template<class U, std::size_t N, typename std::enable_if_t<(N == dynamic_extent || N == extent) && (std::is_convertible_v<std::remove_pointer_t<decltype( std::data(std::declval<T(&)[N]>()))>(*)[], T(*)[]>), bool> = true> constexpr span(std::array<U, N>& arr) noexcept: size_(N), data_{arr.data()} // NOLINT {} template<class U, std::size_t N, typename std::enable_if_t<(N == dynamic_extent || N == extent) && (std::is_convertible_v<std::remove_pointer_t<decltype( std::data(std::declval<T(&)[N]>()))>(*)[], T(*)[]>), bool> = true> constexpr span(const std::array<U, N>& arr) noexcept: size_(N), data_{arr.data()} // NOLINT {} template<class R, class RCV = std::remove_cv_t<std::remove_reference_t<R>>, typename std::enable_if_t< extent != dynamic_extent && span_detail::is_cont_v<RCV> && std::is_convertible_v<std::remove_pointer_t<decltype(std::data(std::declval<R>()))>(*)[], T(*)[]>, bool> = true> explicit constexpr span(R&& range): size_(std::size(range)), data_(std::data(range)) {} template<class R, class RCV = std::remove_cv_t<std::remove_reference_t<R>>, typename std::enable_if_t< extent == dynamic_extent && span_detail::is_cont_v<RCV> && std::is_convertible_v<std::remove_pointer_t<decltype(std::data(std::declval<R>()))>(*)[], T(*)[]>, bool> = true> constexpr span(R&& range): size_(std::size(range)), data_(std::data(range)) // NOLINT {} template<size_type SIZE, typename std::enable_if_t< extent != dynamic_extent && SIZE == extent && std::is_const_v<element_type>, bool> = true> explicit constexpr span(std::initializer_list<value_type> il) noexcept: size_(il.size()), data_(&il.begin()) // NOLINT {} template<size_type SIZE, typename std::enable_if_t< extent == dynamic_extent && SIZE == extent && std::is_const_v<element_type>, bool> = true> explicit span(std::initializer_list<value_type> il) noexcept: size_(il.size()), data_(&il.begin()) // NOLINT {} template<class U, std::size_t N, typename std::enable_if_t< extent != dynamic_extent && N == dynamic_extent && std::is_convertible_v<U(*)[], T(*)[]>, bool> = true> explicit constexpr span(const span<U, N>& source) noexcept: size_{source.size()}, data_{source.data()} {} template<class U, std::size_t N, typename std::enable_if_t< !(extent != dynamic_extent && N == dynamic_extent) && std::is_convertible_v<U(*)[], T(*)[]>, bool> = true> constexpr span(const span<U, N>& source) noexcept: size_{source.size()}, data_{source.data()} // NOLINT {} constexpr span& operator=(const span& copy) { size_ = copy.size(); data_ = copy.data(); return *this; } constexpr span(const span& other) noexcept = default; constexpr iterator begin() const noexcept { return data(); } constexpr iterator end() const noexcept { return data() + size(); } constexpr const_iterator cbegin() const noexcept { return data(); } constexpr const_iterator cend() const noexcept { return data() + size(); } constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } constexpr const_reverse_iterator crbegin() const noexcept { return reverse_iterator{cend()}; } constexpr const_reverse_iterator crend() const noexcept { return reverse_iterator{cbegin()}; } friend constexpr iterator begin(span s) noexcept { return s.begin(); } friend constexpr iterator end(span s) noexcept { return s.end(); } [[nodiscard]] constexpr size_type size() const noexcept { return size_; } [[nodiscard]] constexpr size_type size_bytes() const noexcept { return size() * sizeof(T); } [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0; } constexpr reference operator[](size_type idx) const { return *(data() + idx); } constexpr reference front() const { return *data(); } constexpr reference back() const { return *(data() + (size() - 1)); } constexpr pointer data() const noexcept { return data_; } constexpr span<T, dynamic_extent> first(size_type cnt) const { return {data(), cnt}; } constexpr span<T, dynamic_extent> last(size_type cnt) const { return {data() + (size() - cnt), cnt}; } constexpr span<T, dynamic_extent> subspan(size_type off, size_type cnt = dynamic_extent) const { return {data() + off, cnt == dynamic_extent ? size() - off : cnt}; } }; template<class T, std::size_t N> span(T (&)[N]) -> span<T, N>; template<class T, std::size_t N> span(std::array<T, N>&) -> span<T, N>; template<class T, std::size_t N> span(const std::array<T, N>&) -> span<const T, N>; template<class Cont> span(Cont&) -> span<typename Cont::value_type>; template<class Cont> span(const Cont&) -> span<const typename Cont::value_type>; } #endif //BLT_RANGES_H