Refactor logging API, add StringViewStream other minor QoL updates and changes

Author: Atari2

Playground/main.cpp

@@ -8,16 +8,17 @@
 
 using namespace ARLib;
 int main([[maybe_unused]] int argc, [[maybe_unused]] char** argv) {
-    auto console_logger = MUST(ConsoleLogger::create("default"_s, LogLevel::Trace, "%c%m %l test"));
-    auto file_logger = MUST(FileLogger::create("file"_s, LogLevel::Info, "log.txt"_s));
-    auto string_logger = MUST(StringLogger::create("buffer"_s, LogLevel::Debug, DefaultLogFormat));
+    auto console_logger = MUST(ConsoleLogger::create("default"_s, LogLevel::Trace, "%c%m %l%r test"));
+    auto file_logger    = MUST(FileLoggerTs::create("file"_s, LogLevel::Info, "log.txt"_s));
+    auto string_logger  = MUST(StringLogger::create("buffer"_s, LogLevel::Debug, DefaultLogFormat));
     Logger::register_logger(console_logger);
     Logger::register_logger(file_logger);
     Logger::register_logger(string_logger);
-    for (size_t i = 0; i < 10; i++) {
-        Logger::log(LogLevel::Info, "Hello from {} {}."_sv, "ARLib", i);
-    }
+    for (size_t i = 0; i < 10; i++) { Logger::log_warning("Hello from {} {}."_sv, "ARLib", i); }
     auto logger = Logger::get_named_logger("buffer"_sv);
     if (logger.is_ok()) { Printer::print("String logger contents: {}", logger.to_ok().as<StringLogger>().output()); }
+    console_logger->log_info("This is a test log message with value: {}"_sv, 42);
+    file_logger->log_error("This is an error message with value: {}"_sv, 42);
+    for (const auto& line : string_logger.as<StringLogger>().lines()) { Printer::print("Logged line: {}", line); }
     return 0;
 }

include/EnumHelpers.hpp

@@ -68,12 +68,22 @@ namespace EnumHelpers {
         while ((isspace(view[last_idx]) || view[last_idx] == ',') && last_idx > 0) last_idx--;
         return view.substringview(0, last_idx + 1);
     }
+
+    template <Enum T>
+    constexpr StringView enum_full_string = get_enum_full_string<T>({});
+
+    template <Enum T>
+    constexpr StringView enum_view = strip_trailing_commas(enum_full_string<T>);
+
+    template <Enum T>
+    constexpr size_t enum_count = count_enum_values(enum_view<T>);
+
     template <Enum T>
-    requires(!get_enum_full_string<T>({}).empty())
+    requires(!enum_full_string<T>.empty())
     struct EnumArrayProvider<T> {
         constexpr static auto construct_enum_array(TagType<T>) {
-            constexpr StringView view = strip_trailing_commas(get_enum_full_string<T>({}));
-            Array<Pair<StringView, T>, count_enum_values(view)> enum_map_l;
+            constexpr StringView view = enum_view<T>;
+            Array<Pair<StringView, T>, enum_count<T>> enum_map_l;
             UnderlyingTypeT<T> current_val{};
             auto get_pair = [&view, &current_val](size_t first_idx, size_t second_idx) {
                 constexpr bool Signed = IsSigned<UnderlyingTypeT<T>>;
@@ -115,9 +125,9 @@ namespace EnumHelpers {
     };
     template <Enum T>
     constexpr auto construct_enum_map(
-    const Array<Pair<StringView, T>, count_enum_values(strip_trailing_commas(get_enum_full_string<T>({})))>& enum_array
+    const Array<Pair<StringView, T>, enum_count<T>>& enum_array
     ) {
-        constexpr size_t sz = count_enum_values(strip_trailing_commas(get_enum_full_string<T>({})));
+        constexpr size_t sz = enum_count<T>;
         EnumStrHashMap<T, sz> map;
         for (const auto& [k, v] : enum_array) {
             const bool inserted = map.insert(v, k);

include/Iterator.hpp

@@ -18,17 +18,17 @@ class IteratorBase {
     constexpr IteratorBase(IteratorBase<T>&& other) noexcept : m_current(other.m_current) { other.m_current = nullptr; }
 
     public:
+    constexpr const T* const ptr() const { return m_current; }
     constexpr bool operator==(const IteratorBase<T>& other) const { return m_current == other.m_current; }
     constexpr bool operator!=(const IteratorBase<T>& other) const { return m_current != other.m_current; }
     constexpr bool operator<(const IteratorBase<T>& other) { return m_current < other.m_current; }
     constexpr bool operator>(const IteratorBase<T>& other) { return m_current > other.m_current; }
 };
-// for some godforsaken reason
-#define m_current IteratorBase<T>::m_current
 template <typename T>
 class Iterator final : public IteratorBase<T> {
+    using IteratorBase<T>::m_current;
     public:
-    explicit Iterator(T* start) : IteratorBase<T>(start) {}
+    constexpr explicit Iterator(T* start) : IteratorBase<T>(start) {}
     Iterator(const Iterator<T>& other) : IteratorBase<T>(other) {}
     Iterator(Iterator<T>&& other) noexcept : IteratorBase<T>(other) {}
     T& operator*() { return *m_current; }
@@ -74,6 +74,7 @@ class Iterator final : public IteratorBase<T> {
 };
 template <typename Ct>
 class ConstIterator final : public IteratorBase<typename AddConst<Ct>::type> {
+    using IteratorBase<typename AddConst<Ct>::type>::m_current;
 
     public:
     using T = AddConstT<Ct>;
@@ -125,6 +126,7 @@ class ConstIterator final : public IteratorBase<typename AddConst<Ct>::type> {
 };
 template <typename T>
 class ReverseIterator final : public IteratorBase<T> {
+    using IteratorBase<T>::m_current;
     public:
     explicit ReverseIterator(T* end) : IteratorBase<T>(end) {}
     ReverseIterator(const ReverseIterator<T>& other) : IteratorBase<T>(other.m_current) {}
@@ -168,6 +170,7 @@ class ReverseIterator final : public IteratorBase<T> {
 template <typename Ct>
 class ConstReverseIterator final : public IteratorBase<typename AddConst<Ct>::type> {
     using T = typename AddConst<Ct>::type;
+    using IteratorBase<T>::m_current;
 
     public:
     explicit ConstReverseIterator(T* end) : IteratorBase<T>(end) {}
@@ -211,7 +214,6 @@ class ConstReverseIterator final : public IteratorBase<typename AddConst<Ct>::ty
     }
     ConstReverseIterator<Ct> operator-(Integral auto offset) { return { m_current + offset }; }
 };
-#undef m_current
 template <typename T, ComparatorType CMP, typename = EnableIfT<IsNonboolIntegral<T>>>
 class LoopIterator {
     T m_current;

include/Logger.hpp

@@ -12,12 +12,13 @@ constexpr static inline uint8_t _newline_buffer[]{ '\n' };
 constexpr static inline Span<const uint8_t> _newline_span{ _newline_buffer };
 MAKE_FANCY_ENUM(LogLevel, uint8_t, Critical = 5, Error = 4, Warning = 3, Info = 2, Debug = 1, Trace = 0);
 MAKE_FANCY_ENUM(LoggingError, uint8_t, FormatError, OutputError, OpenStreamError, LoggerNotFoundError);
-constexpr StringView DefaultLogFormat = "%c[%n|%l - %u][%t]%r %m";
+constexpr StringView DefaultLogFormat     = "%c[%n|%l - %u][%t]%r %m";
 constexpr StringView DefaultLogFileFormat = "[%n|%l - %u][%t] %m";
 class LoggingFormat {
-    enum class LoggingFormatSpecifier {
+    enum class LoggingFormatSpecifier : uint8_t {
         Message,
         LogLevel,
+        LogLevelShort,
         Timestamp,
         ThreadId,
         DefaultColor,
@@ -32,21 +33,61 @@ 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)>>;
+
+template <typename T>
+concept LoggingPrintable = Printable<RemoveReferenceT<T>>;
 class LoggingBackend {
     String m_name;
     LogLevel m_level;
     LoggingFormat m_format;
     friend class LoggingBackendTs;
+    friend class Logger;
+    public:
+    using LogResult = DiscardResult<LoggingError>;
     protected:
     String format_message(StringView message, LogLevel level) const;
-    protected:
     LoggingBackend(String name, LogLevel level, LoggingFormat format) :
         m_name{ name }, m_level{ level }, m_format{ format } {}
+    virtual LogResult log(LogLevel level, StringView message) = 0;
     public:
-    using LogResult = DiscardResult<LoggingError>;
     constexpr bool should_log(LogLevel level) const { return level >= m_level; }
     const String& name() const { return m_name; }
-    virtual LogResult log(LogLevel level, StringView message) = 0;
+    template <LoggingPrintable... Args>
+    LogResult log(LogLevel level, LoggerStringParam<Args...> str, Args&&... args) {
+        auto formatted_string = Printer::format(move(str), Forward<Args>(args)...);
+        return log(level, formatted_string);
+    }
+    template <LoggingPrintable... Args>
+    LogResult log_critical(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Critical, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    LogResult log_error(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Error, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    LogResult log_warning(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Warning, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    LogResult log_info(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Info, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    LogResult log_debug(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Debug, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    LogResult log_trace(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Trace, move(str), Forward<Args>(args)...);
+    }
     virtual bool supports_color() { return false; }
     virtual ~LoggingBackend() = default;
 };
@@ -154,8 +195,9 @@ class FileLogger : public StreamLogger<FileStream> {
 };
 class BufferedFileLogger : public StreamLogger<BufferedFileStream> {
     String m_file_path;
-    BufferedFileLogger(String name, LogLevel level, LoggingFormat format, String file_path, BufferedFileStream&& stream) :
-        StreamLogger<BufferedFileStream>{ name, level, format, move(stream) }, m_file_path{ move(file_path) } {}
+    BufferedFileLogger(
+    String name, LogLevel level, LoggingFormat format, String file_path, BufferedFileStream&& stream
+    ) : StreamLogger<BufferedFileStream>{ name, level, format, move(stream) }, m_file_path{ move(file_path) } {}
     public:
     static Result<SharedPtr<LoggingBackend>, LoggingError>
     create(String name, LogLevel level, String file_path, StringView format = DefaultLogFileFormat) {
@@ -179,12 +221,12 @@ class StringLogger : public StreamLogger<StringStream> {
         };
     }
     String output() const { return m_stream->str(); }
+    auto lines() const { return StringViewStream{ *m_stream }.lines_view(); }
 };
 class FileLoggerTs : public StreamLoggerTs<FileStream> {
     String m_file_path;
     FileLoggerTs(String name, LogLevel level, LoggingFormat format, String file_path, FileStream&& stream) :
-        StreamLoggerTs<FileStream>{ name, level, format, move(stream) }, m_file_path{ move(file_path) } {
-    }
+        StreamLoggerTs<FileStream>{ name, level, format, move(stream) }, m_file_path{ move(file_path) } {}
     public:
     static Result<SharedPtr<LoggingBackend>, LoggingError>
     create(String name, LogLevel level, String file_path, StringView format = DefaultLogFileFormat) {
@@ -247,30 +289,23 @@ class Logger {
     }
     public:
     static void register_logger(SharedPtr<LoggingBackend> backend) {
-        auto name_copy = backend->name();
+        String name_copy = backend->name();
         store().add_backend(move(name_copy), move(backend));
     }
     static LoggingStorage::ResultType get_named_logger(StringView name);
     static LoggingStorage::ResultType get_default_logger();
-#ifdef __INTELLISENSE__
-    #define LOGGER_STRING_PARAM_TYPE StringView
-#else
-    #define LOGGER_STRING_PARAM_TYPE FormatString<sizeof...(Args)>
-#endif
-    template <typename... Args>
-    requires(... && Printable<RemoveReferenceT<Args>>)
+    template <LoggingPrintable... Args>
     static LoggingBackend::LogResult
-    log(StringView logger_name, LogLevel level, LOGGER_STRING_PARAM_TYPE str, Args&&... args) {
+    log(StringView logger_name, LogLevel level, LoggerStringParam<Args...> str, Args&&... args) {
         auto formatted_string = Printer::format(move(str), Forward<Args>(args)...);
         if (auto it = store().get(logger_name); it.is_ok()) {
             auto backend = it.to_ok();
             TRY(backend->log(level, formatted_string));
         }
         return {};
     }
-    template <typename... Args>
-    requires(... && Printable<RemoveReferenceT<Args>>)
-    static LoggingBackend::LogResult log(LogLevel level, LOGGER_STRING_PARAM_TYPE str, Args&&... args) {
+    template <LoggingPrintable... Args>
+    static LoggingBackend::LogResult log(LogLevel level, LoggerStringParam<Args...> str, Args&&... args) {
         auto formatted_string = Printer::format(move(str), Forward<Args>(args)...);
         auto& sync_store      = Logger::store();
         return sync_store.m_store.with_lock(
@@ -280,5 +315,29 @@ class Logger {
         }
         );
     }
+    template <LoggingPrintable... Args>
+    static LoggingBackend::LogResult log_critical(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Critical, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    static LoggingBackend::LogResult log_error(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Error, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    static LoggingBackend::LogResult log_warning(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Warning, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    static LoggingBackend::LogResult log_info(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Info, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    static LoggingBackend::LogResult log_debug(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Debug, move(str), Forward<Args>(args)...);
+    }
+    template <LoggingPrintable... Args>
+    static LoggingBackend::LogResult log_trace(LoggerStringParam<Args...> str, Args&&... args) {
+        return log(LogLevel::Trace, move(str), Forward<Args>(args)...);
+    }
 };
 }    // namespace ARLib

include/Stream.hpp

@@ -52,8 +52,8 @@ struct CharacterStream : public BaseStream {
         LinesIterator begin() const;
         LinesIterator end() const;
     };
-    virtual Lines lines() &  = 0;
-    virtual Lines lines() && = 0;
+    virtual Lines lines() &      = 0;
+    virtual Lines lines() &&     = 0;
     virtual DiscardResult<FileError> open() { return DefaultOk{}; }
     virtual Result<size_t> write_string(StringView buffer) = 0;
     virtual Result<String> read_string()                   = 0;
@@ -127,6 +127,7 @@ class BufferedFileStream : public FileStream {
 class StringStream : public CharacterStream {
     size_t m_pos{ 0 };
     String m_buffer;
+    friend class StringViewStream;
     public:
     StringStream() = default;
     StringStream(String buffer) : m_buffer{ move(buffer) } {}
@@ -149,4 +150,67 @@ class StringStream : public CharacterStream {
     bool is_open() const override { return true; }
     virtual ~StringStream() = default;
 };
+class StringViewStream : public CharacterStream {
+    size_t m_pos{ 0 };
+    StringView m_view;
+    public:
+    class LinesViewIterator {
+        MaybeOwned<StringViewStream> m_stream;
+        bool m_eof_reached{ false };
+        bool m_end{ false };
+        StringView m_current_line{};
+        public:
+        LinesViewIterator(MaybeOwned<StringViewStream> stream, bool end = false);
+        StringView operator*();
+        LinesViewIterator& operator++();
+        LinesViewIterator operator++(int);
+        bool operator==(const LinesViewIterator& other) const;
+        bool operator!=(const LinesViewIterator& other) const;
+    };
+    class LinesView {
+        MaybeOwned<StringViewStream> m_stream;
+        public:
+        LinesView(StringViewStream& stream) :
+            m_stream{ MaybeOwned<StringViewStream>::template lended<StringViewStream>(stream) } {
+            if (auto& fs = *m_stream; !fs.is_open()) { fs.open(); }
+        }
+        LinesView(StringViewStream&& stream) :
+            m_stream{
+                MaybeOwned<StringViewStream>::template owned<StringViewStream>(Forward<StringViewStream>(stream))
+            } {
+            if (auto& fs = *m_stream; !fs.is_open()) { fs.open(); }
+        }
+        LinesViewIterator begin();
+        LinesViewIterator end();
+        LinesViewIterator begin() const;
+        LinesViewIterator end() const;
+    };
+    StringViewStream() = default;
+    StringViewStream(const StringStream& stream) : m_pos{ stream.m_pos }, m_view{ stream.m_buffer } {}
+    StringViewStream(StringView view) : m_view{ move(view) } {}
+    StringViewStream(const String& str) : m_view{ str.view() } {}
+    Result<size_t> write(Span<const uint8_t> buffer) override;
+    Result<size_t> write(Span<const char> buffer) override;
+    Result<size_t> write(StringView view) override;
+    Result<Vector<uint8_t>> read(size_t n) override;
+    Result<Vector<uint8_t>> read() override;
+    Result<size_t> write_string(StringView buffer) override;
+    Result<String> read_string() override;
+    Result<String> read_line(bool& eof_reached) override;
+    Result<StringView> read_string_view();
+    Result<StringView> read_line_view(bool& eof_reached);
+    Lines lines() & override { return Lines{ *this }; }
+    Lines lines() && override { return Lines{ move(*this) }; }
+    LinesView lines_view() & { return LinesView{ *this }; }
+    LinesView lines_view() && { return LinesView{ move(*this) }; }
+    size_t pos() const override { return m_pos; }
+    size_t seek(size_t pos) override {
+        m_pos = pos;
+        return m_pos;
+    }
+    StringView view() const { return m_view; }
+    String str() const { return m_view.str(); }
+    bool is_open() const override { return true; }
+    virtual ~StringViewStream() = default;
+};
 }    // namespace ARLib