Refactor enums, StringView, Span printing & streams

Atari2 · Atari2 · commit bcf89cf1f217 · 2026-03-21T12:05:11.000+01:00
diff --git a/include/EnumHelpers.hpp b/include/EnumHelpers.hpp
@@ -103,7 +103,7 @@ namespace EnumHelpers {
                     Signed ? static_cast<Ut>(cxpr::StrViewToI64(sub.substringview_fromlen(equal_idx + 1))) :
                                    static_cast<Ut>(cxpr::StrViewToU64(sub.substringview_fromlen(equal_idx + 1)))
                     );
-                    current_val = from_enum(value) + UnderlyingTypeT<T>{ 1 };
+                    current_val = from_enum(value) + Ut{ 1 };
                     return Pair{ sub.substringview_fromlen(
                                  first_nospace_idx,
                                  (last_nospace_idx < equal_idx ? last_nospace_idx : equal_idx) - first_nospace_idx
@@ -132,7 +132,7 @@ namespace EnumHelpers {
         for (const auto& [k, v] : enum_array) {
             const bool inserted = map.insert(v, k);
             if (is_constant_evaluated()) {
-                // this allocation is here for the same reason as the one at line 178
+                // this allocation is here for the same reason as the one as below in enum_to_str_view
                 if (!inserted) { new int[static_cast<size_t>(from_enum(v))]; }
             }
         }
@@ -223,7 +223,7 @@ Optional<T> enum_parse(StringView v) {
         return p.second();
     });
 }
-template <typename T>
+template <Enum T>
 constexpr bool enum_has_value(StringView ename) {
     if constexpr (EnumHelpers::EnumSupportsMap<T>) {
         constexpr const auto& enum_map = EnumHelpers::EnumMapProvider<T>::enum_array;
@@ -235,7 +235,7 @@ constexpr bool enum_has_value(StringView ename) {
         return true;    // lie about "None" support because not all enums are "fancy" and we don't want a static_assert fail on those.
     }
 }
-template <typename T>
+template <Enum T>
 constexpr T get_enum_none() {
     if constexpr (requires { T::None; }) {
         return T::None;
@@ -256,8 +256,7 @@ template <EnumHelpers::EnumSupportsMap T>
 constexpr auto for_each_enum() {
     return ForEachEnum<T>{};
 }
-template <EnumHelpers::EnumSupportsMap T, typename Functor>
-requires(requires { declval<Functor>()(declval<T>()); })
+template <EnumHelpers::EnumSupportsMap T, CallableWith<T> Functor>
 constexpr auto for_each_enum(Functor func) {
     using Res = InvokeResultT<Functor, T>;
     if constexpr (IsVoid<Res>::value) {
diff --git a/include/Logger.hpp b/include/Logger.hpp
@@ -33,11 +33,6 @@ class LoggingFormat {
     static Result<LoggingFormat, LoggingError> from_string(StringView format);
     String format_message(StringView message, LogLevel level, StringView logger_name) const;
 };
-#ifdef __INTELLISENSE__
-constexpr bool is_intellisense = true;
-#else
-constexpr bool is_intellisense = false;
-#endif
 template <typename... Args>
 using LoggerStringParam = ConditionalT<is_intellisense, StringView, FormatString<sizeof...(Args)>>;
 
diff --git a/include/Macros.hpp b/include/Macros.hpp
@@ -38,3 +38,8 @@
 
 
 #define USE_NEW_TUPLE 1
+#ifdef __INTELLISENSE__
+constexpr bool is_intellisense = true;
+#else
+constexpr bool is_intellisense = false;
+#endif
diff --git a/include/Span.hpp b/include/Span.hpp
@@ -3,6 +3,7 @@
 #include "Utility.hpp"
 #include "Iterator.hpp"
 #include "Pair.hpp"
+#include "PrintInfo.hpp"
 namespace ARLib {
 template <typename T>
 class Span {
@@ -51,4 +52,19 @@ class Span {
     }
     constexpr bool operator==(const Span& other) const noexcept = default;
 };
+
+template <Printable T>
+struct PrintInfo<Span<T>> {
+    const Span<T>& m_span;
+    PrintInfo(const Span<T>& span) : m_span(span) {}
+    String repr() const {
+        String result = "["_s;
+        for (size_t i = 0; i < m_span.size(); i++) {
+            result += print_conditional(m_span[i]);
+            if (i != m_span.size() - 1) { result += ", "; }
+        }
+        result += "]";
+        return result;
+    }
+};
 }    // namespace ARLib
diff --git a/include/Stream.hpp b/include/Stream.hpp
@@ -153,6 +153,7 @@ class StringStream : public CharacterStream {
 class StringViewStream : public CharacterStream {
     size_t m_pos{ 0 };
     StringView m_view;
+    Span<char> _writeable_span();
     public:
     class LinesViewIterator {
         MaybeOwned<StringViewStream> m_stream;
diff --git a/include/StringView.hpp b/include/StringView.hpp
@@ -9,7 +9,6 @@ template <typename T>
 class Vector;
 // this class is not necessarily null-terminated
 class StringView {
-    char* m_start_mut   = nullptr;
     const char* m_start = nullptr;
     size_t m_size       = 0;
     [[noreturn]] static void cxpr_error() {
@@ -26,13 +25,13 @@ class StringView {
     constexpr StringView(const char* begin, const char* end) :
         m_start(begin), m_size(static_cast<size_t>(end - begin)) {}
     constexpr StringView(char* begin, const char* end) :
-        m_start_mut(begin), m_start(begin), m_size(static_cast<size_t>(end - begin)) {}
+        m_start(begin), m_size(static_cast<size_t>(end - begin)) {}
     template <typename T>
     requires IsSameV<T, const char*>
     constexpr StringView(T buf, size_t size) : m_start(buf), m_size(size) {}
     template <typename T>
     requires IsSameV<T, char*>
-    constexpr StringView(T buf, size_t size) : m_start_mut(buf), m_start(buf), m_size(size) {}
+    constexpr StringView(T buf, size_t size) : m_start(buf), m_size(size) {}
     template <size_t N>
     constexpr StringView(const char (&buf)[N]) : m_start(buf), m_size(strlen(buf)) {}
     template <typename T>
@@ -42,35 +41,30 @@ class StringView {
     }
     template <typename T>
     requires IsSameV<T, char*>
-    constexpr StringView(T buf) : m_start_mut(buf), m_start(buf) {
+    constexpr StringView(T buf) : m_start(buf) {
         m_size = strlen(buf);
     }
     constexpr StringView(Iterator<char> begin, Iterator<char> end) :
         m_start(begin.ptr()), m_size(static_cast<size_t>(end.ptr() - begin.ptr())) {}
     constexpr StringView(ConstIterator<char> begin, ConstIterator<char> end) :
         m_start(begin.ptr()), m_size(static_cast<size_t>(end.ptr() - begin.ptr())) {}
     explicit StringView(const String& ref) : m_start(ref.data()) { m_size = ref.length(); }
-    explicit StringView(String& ref) : m_start_mut(ref.rawptr()), m_start(ref.data()) { m_size = ref.length(); }
     constexpr StringView(const StringView& view) = default;
     constexpr StringView(StringView&& view) noexcept {
-        m_start_mut  = view.m_start_mut;
         m_start      = view.m_start;
         m_size       = view.m_size;
         view.m_start = nullptr;
         view.m_size  = 0;
     }
     constexpr StringView& operator=(const StringView& view) noexcept {
         if (this == &view) return *this;
-        m_start_mut = view.m_start_mut;
         m_start     = view.m_start;
         m_size      = view.m_size;
         return *this;
     }
     constexpr StringView& operator=(StringView&& view) noexcept {
-        m_start_mut      = view.m_start_mut;
         m_start          = view.m_start;
         m_size           = view.m_size;
-        view.m_start_mut = nullptr;
         view.m_start     = nullptr;
         view.m_size      = 0;
         return *this;
@@ -101,18 +95,12 @@ class StringView {
     }
     constexpr bool empty() const { return size() == 0; }
     [[nodiscard]] Ordering operator<=>(const StringView& other) const;
+    constexpr char first() const { return m_start[0]; }
+    constexpr char last() const { return m_start[m_size - 1]; }
     constexpr char operator[](size_t index) const noexcept { return m_start[index]; }
     constexpr const char& index(size_t index) const noexcept { return m_start[index]; }
-    constexpr char& index(size_t index) noexcept {
-        HARD_ASSERT(m_start_mut, "This stringview is not mutable")
-        return m_start_mut[index];
-    }
     [[nodiscard]] constexpr StringView substring(size_t size) {
-        if (m_start_mut) {
-            return StringView{ m_start_mut, size };
-        } else {
-            return StringView{ m_start, size };
-        }
+        return StringView{ m_start, size };
     }
     [[nodiscard]] constexpr size_t index_of(const char* c, size_t start = 0) const {
         if (m_size == 0 || start >= m_size) return npos;
@@ -133,10 +121,6 @@ class StringView {
     [[nodiscard]] constexpr size_t size() const { return m_size; }
     [[nodiscard]] constexpr size_t length() const { return m_size; }
     [[nodiscard]] constexpr const char* data() const { return m_start; }
-    [[nodiscard]] constexpr char* rawptr() {
-        HARD_ASSERT(m_start_mut, "This stringview is not mutable")
-        return m_start_mut;
-    }
     [[nodiscard]] constexpr ConstIterator<char> begin() const { return ConstIterator<char>{ m_start }; }
     [[nodiscard]] constexpr ConstIterator<char> end() const { return ConstIterator<char>{ m_start + m_size }; }
     [[nodiscard]] String str() const { return { m_start, length() }; }
@@ -145,11 +129,7 @@ class StringView {
         size_t ssize = size();
         if (first > ssize) return {};
         if (last > ssize) return StringView{ m_start + first, m_size - first };
-        if (m_start_mut) {
-            return StringView{ m_start_mut + first, m_start + last };
-        } else {
-            return StringView{ m_start + first, m_start + last };
-        }
+        return StringView{ m_start + first, m_start + last };
     }
     constexpr StringView substringview_fromlen(size_t first = 0, size_t len = npos) const {
         if (is_constant_evaluated()) { check_offset(first); }
diff --git a/source/Logger.cpp b/source/Logger.cpp
@@ -97,7 +97,7 @@ String LoggingFormat::format_message(StringView message, LogLevel level, StringV
                     output.append(enum_to_str_view(level));
                     break;
                 case LoggingFormatSpecifier::LogLevelShort:
-                    output.append(enum_to_str_view(level)[0]); 
+                    output.append(enum_to_str_view(level).first()); 
                     break;
                 case LoggingFormatSpecifier::LoggerName:
                     output.append(logger_name);
diff --git a/source/Stream.cpp b/source/Stream.cpp
@@ -302,33 +302,41 @@ StringViewStream::LinesViewIterator StringViewStream::LinesViewIterator::operato
     ++(*this);
     return copy;
 }
+Span<char> StringViewStream::_writeable_span() {
+    // this const_cast is fine because the pointer underlying the StringView is writable when created
+    // it's just necessary because the StringView itself doesn't allow modifications.
+    return Span<char>{ const_cast<char*>(m_view.data()), m_view.size() };
+}
 Result<size_t> StringViewStream::write(Span<const uint8_t> buffer) {
     StringView bufview{ reinterpret_cast<const char*>(buffer.data()), buffer.size_bytes() };
+    auto writeable_span = _writeable_span();
     int64_t to_write   = static_cast<int64_t>(bufview.size());
     int64_t space_left = static_cast<int64_t>(m_view.size() - m_pos);
     if (auto needed_space = to_write - space_left; needed_space > 0) {
         return Error{ "Cannot write to StringViewStream: not enough space" };
     }
-    for (size_t i = 0; to_write > 0; --to_write, ++m_pos, ++i) { m_view.index(m_pos) = bufview[i]; }
+    for (size_t i = 0; to_write > 0; --to_write, ++m_pos, ++i) { writeable_span[m_pos] = bufview[i]; }
     return static_cast<size_t>(to_write);
 }
 Result<size_t> StringViewStream::write(Span<const char> buffer) {
     StringView bufview{ buffer.data(), buffer.size_bytes() };
+    auto writeable_span = _writeable_span();
     int64_t to_write   = static_cast<int64_t>(bufview.size());
     int64_t space_left = static_cast<int64_t>(m_view.size() - m_pos);
     if (auto needed_space = to_write - space_left; needed_space > 0) {
         return Error{ "Cannot write to StringViewStream: not enough space" };
     }
-    for (size_t i = 0; to_write > 0; --to_write, ++m_pos, ++i) { m_view.index(m_pos) = bufview[i]; }
+    for (size_t i = 0; to_write > 0; --to_write, ++m_pos, ++i) { writeable_span[m_pos] = bufview[i]; }
     return static_cast<size_t>(to_write);
 }
 Result<size_t> StringViewStream::write(StringView bufview) {
-    int64_t to_write   = static_cast<int64_t>(bufview.size());
+    int64_t to_write    = static_cast<int64_t>(bufview.size());
+    auto writeable_span = _writeable_span();
     int64_t space_left = static_cast<int64_t>(m_view.size() - m_pos);
     if (auto needed_space = to_write - space_left; needed_space > 0) {
         return Error{ "Cannot write to StringViewStream: not enough space" };
     }
-    for (size_t i = 0; to_write > 0; --to_write, ++m_pos, ++i) { m_view.index(m_pos) = bufview[i]; }
+    for (size_t i = 0; to_write > 0; --to_write, ++m_pos, ++i) { writeable_span[m_pos] = bufview[i]; }
     return static_cast<size_t>(to_write);
 }
 Result<Vector<uint8_t>> StringViewStream::read(size_t n) {
@@ -344,12 +352,13 @@ Result<Vector<uint8_t>> StringViewStream::read() {
     return Vector<uint8_t>{ ptr, m_view.size() };
 }
 Result<size_t> StringViewStream::write_string(StringView buffer) {
+    auto writeable_span = _writeable_span();
     int64_t to_write   = static_cast<int64_t>(buffer.size());
     int64_t space_left = static_cast<int64_t>(m_view.size() - m_pos);
     if (auto needed_space = to_write - space_left; needed_space > 0) {
         return Error{ "Cannot write to StringViewStream: not enough space" };
     }
-    for (size_t i = 0; to_write > 0; --to_write, ++m_pos, ++i) { m_view.index(m_pos) = buffer[i]; }
+    for (size_t i = 0; to_write > 0; --to_write, ++m_pos, ++i) { writeable_span[m_pos] = buffer[i]; }
     return static_cast<size_t>(to_write);
 }
 Result<String> StringViewStream::read_string() {
