From ba30caa9b24ee7dbebb524a218d97ec28fe8a0f5 Mon Sep 17 00:00:00 2001
From: Gary Talent <gary@drinkingtea.net>
Date: Sat, 30 Sep 2023 13:38:04 -0500
Subject: [PATCH] [ox/std] Add SpanView

---
 deps/ox/src/ox/std/span.hpp | 117 +++++++++++++++++++++++++++++++++---
 1 file changed, 107 insertions(+), 10 deletions(-)

diff --git a/deps/ox/src/ox/std/span.hpp b/deps/ox/src/ox/std/span.hpp
index d317e969..397849c5 100644
--- a/deps/ox/src/ox/std/span.hpp
+++ b/deps/ox/src/ox/std/span.hpp
@@ -17,7 +17,7 @@
 namespace ox {
 
 template<typename T>
-class Span {
+class SpanView {
 
 	private:
 		const T *m_items{};
@@ -31,24 +31,125 @@ class Span {
 		using iterator = SpanIterator<T, RefType, PtrType, reverse>;
 
 		template<std::size_t sz>
-		constexpr Span(ox::Array<T, sz> const&a) noexcept:
+		constexpr SpanView(ox::Array<T, sz> const&a) noexcept:
 			m_items(a.data()),
 			m_size(a.size()) {
 		}
 
-		template<std::size_t sz>
-		constexpr Span(ox::Vector<T, sz> const&v) noexcept:
+		template<std::size_t sz, typename Allocator>
+		constexpr SpanView(ox::Vector<T, sz, Allocator> const&v) noexcept:
 			m_items(v.data()),
 			m_size(v.size()) {
 		}
 
 		template<std::size_t sz>
-		constexpr Span(const T a[sz]) noexcept:
+		constexpr SpanView(const T a[sz]) noexcept:
 			m_items(a),
 			m_size(sz) {
 		}
 
-		constexpr Span(const T *a, std::size_t sz) noexcept:
+		constexpr SpanView(const T *a, std::size_t sz) noexcept:
+			m_items(a),
+			m_size(sz) {
+		}
+
+		constexpr iterator<> begin() noexcept {
+			return iterator<>(m_items, 0, m_size);
+		}
+
+		constexpr iterator<> end() noexcept {
+			return iterator<>(m_items, m_size, m_size);
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const T&, const T*> begin() const noexcept {
+			return iterator<const T&, const T*>(m_items, 0, m_size);
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const T&, const T*> end() const noexcept {
+			return iterator<const T&, const T*>(m_items, m_size, m_size);
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const T&, const T*> cbegin() const noexcept {
+			return iterator<const T&, const T*>(m_items, 0, m_size);
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const T&, const T*> cend() const noexcept {
+			return iterator<const T&, const T*>(m_items, m_size, m_size);
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const T&, const T*, true> crbegin() const noexcept {
+			return iterator<const T&, const T*, true>(m_items, m_size - 1, m_size);
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const T&, const T*, true> crend() const noexcept {
+			return iterator<const T&, const T*, true>(m_items, MaxValue<size_type>, m_size);
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const T&, const T*, true> rbegin() const noexcept {
+			return iterator<const T&, const T*, true>(m_items, m_size - 1, m_size);
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const T&, const T*, true> rend() const noexcept {
+			return iterator<const T&, const T*, true>(m_items, MaxValue<size_type>, m_size);
+		}
+
+		constexpr const T &operator[](std::size_t i) const noexcept {
+			return m_items[i];
+		}
+
+		[[nodiscard]]
+		constexpr std::size_t size() const noexcept {
+			return m_size;
+		}
+
+		[[nodiscard]]
+		constexpr bool empty() const noexcept {
+			return m_size == 0;
+		}
+
+};
+
+template<typename T>
+class Span {
+
+	private:
+		T *m_items{};
+		const std::size_t m_size{};
+
+	public:
+		using value_type = T;
+		using size_type = std::size_t;
+
+		template<typename RefType = T&, typename PtrType = T*, bool reverse = false>
+		using iterator = SpanIterator<T, RefType, PtrType, reverse>;
+
+		template<std::size_t sz>
+		constexpr Span(ox::Array<T, sz> &a) noexcept:
+			m_items(a.data()),
+			m_size(a.size()) {
+		}
+
+		template<std::size_t sz, typename Allocator>
+		constexpr Span(ox::Vector<T, sz, Allocator> &v) noexcept:
+			m_items(v.data()),
+			m_size(v.size()) {
+		}
+
+		template<std::size_t sz>
+		constexpr Span(T a[sz]) noexcept:
+			m_items(a),
+			m_size(sz) {
+		}
+
+		constexpr Span(T *a, std::size_t sz) noexcept:
 			m_items(a),
 			m_size(sz) {
 		}
@@ -111,10 +212,6 @@ class Span {
 			return iterator<const T&, const T*, true>(m_items, MaxValue<size_type>, m_size);
 		}
 
-		constexpr T &operator[](std::size_t i) noexcept {
-			return m_items[i];
-		}
-
 		constexpr const T &operator[](std::size_t i) const noexcept {
 			return m_items[i];
 		}