ALogger.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <AUI/Core.h>
#include <AUI/IO/APath.h>
#include <AUI/IO/IOutputStream.h>
#include <AUI/Reflect/AReflect.h>
#include <AUI/Util/ARaiiHelper.h>
#include "AUI/Thread/AMutex.h"
#include "AUI/IO/AFileOutputStream.h"
#include <fmt/format.h>
#include <fmt/chrono.h>
#include <AUI/Thread/AMutexWrapper.h>
 
class AString;

class API_AUI_CORE ALogger final
{
public:
   enum Level
   {
       INFO,
       WARN,
       ERR,
       DEBUG,
   };
 
   struct LogWriter {
       private:
           ALogger& mLogger;
           Level mLevel;
           AString mPrefix;
           struct Buffer {
           private:
               struct StackBuffer {
                   char buffer[2048];
                   char* currentIterator;
               };
               using HeapBuffer = AVector<char>;
               std::variant<StackBuffer, HeapBuffer> mBuffer;
 
               void switchToHeap() {
                   HeapBuffer h;
                   h.reserve(16384);
                   auto& stack = std::get<StackBuffer>(mBuffer);
                   h.insert(h.end(), stack.buffer, stack.currentIterator);
                   mBuffer = std::move(h);
               }
           public:
               using value_type = char;
 
               Buffer() noexcept: mBuffer({}) {
                   auto& sb = std::get<StackBuffer>(mBuffer);
                   sb.currentIterator = sb.buffer;
               }
               size_t write(const char* t, size_t s) {
                   if (std::holds_alternative<StackBuffer>(mBuffer)) {
                       auto& stack = std::get<StackBuffer>(mBuffer);
                       if (stack.currentIterator + s <= stack.buffer + sizeof(stack.buffer)) {
                           std::memcpy(stack.currentIterator, t, s);
                           stack.currentIterator += s;
                           return s;
                       }
                       switchToHeap();
                   }
                   auto& h = std::get<HeapBuffer>(mBuffer);
                   h.insert(h.end(), t, t + s);
                   return s;
               }
               void write(char c) {
                   if (std::holds_alternative<StackBuffer>(mBuffer)) {
                       auto& stack = std::get<StackBuffer>(mBuffer);
                       if (stack.currentIterator + sizeof(c) <= stack.buffer + sizeof(stack.buffer)) {
                           *stack.currentIterator = c;
                           stack.currentIterator += 1;
                           return;
                       }
                       switchToHeap();
                   }
                   std::get<HeapBuffer>(mBuffer).push_back(c);
               }
 
               void push_back(char c) { // for std::back_inserter
                   write(c);
               }
 
               [[nodiscard]]
               std::string_view str() const {
                   // assuming there's a null terminator
                   if (std::holds_alternative<StackBuffer>(mBuffer)) {
                       auto& stack = std::get<StackBuffer>(mBuffer);
                       return {stack.buffer, static_cast<std::string_view::size_type>(stack.currentIterator - stack.buffer) - 1};
                   }
                   auto& h = std::get<HeapBuffer>(mBuffer);
                   return {h.data(), h.size()};
               }
           };
 
           struct LazyStreamBuf final: std::streambuf {
           private:
               Buffer& stackBuffer;
           public:
               std::ostream stream;
               LazyStreamBuf(Buffer& stackBuffer) : stackBuffer(stackBuffer), stream(this) {}
 
           protected:
               std::streamsize xsputn(const char_type* s, std::streamsize n) override {
                   return stackBuffer.write(s, n);
               }
 
               int overflow(int_type __c) override {
                   stackBuffer.write(__c);
                   return 1;
               }
           };
           AOptional<LazyStreamBuf> mStreamBuf;
 
           Buffer mBuffer;
 
           void writeTimestamp(const char* fmt, std::chrono::system_clock::time_point t) noexcept {
               fmt::format_to(std::back_inserter(mBuffer), "{}", t);
           }
 
       public:
           LogWriter(ALogger& logger, Level level, AString prefix) :
               mLogger(logger),
               mLevel(level),
               mPrefix(std::move(prefix)) {
 
           }
 
           ~LogWriter() {
               mBuffer.write(0); // null terminator
               auto s = mBuffer.str();
               mLogger.log(mLevel, mPrefix.toStdString().c_str(), s);
           }
 
           template<typename T>
           LogWriter& operator<<(const T& t) noexcept {
               // avoid usage of std::ostream because it's expensive
               if constexpr(std::is_constructible_v<std::string_view, T>) {
                   std::string_view stringView(t);
                   mBuffer.write(stringView.data(), stringView.size());
               } else if constexpr(std::is_base_of_v<AString, T>) {
                   *this << t.toStdString();
               } else if constexpr(std::is_base_of_v<std::exception, T> && !std::is_base_of_v<AException, T>) {
                   *this << "(" << AReflect::name(&t) << ") " << t.what();
               } else if constexpr(std::is_same_v<std::chrono::seconds, T>) {
                   writeTimestamp("%D %T", std::chrono::system_clock::time_point(t));
               } else if constexpr(std::is_same_v<std::chrono::minutes, T> || std::is_same_v<std::chrono::hours, T>) {
                   writeTimestamp("%D %R", std::chrono::system_clock::time_point(t));
               } else {
                   if (!mStreamBuf) {
                       mStreamBuf.emplace(mBuffer);
                   }
                   mStreamBuf->stream << t;
               }
               return *this;
           }
   };
 

   ALogger(AString filename) {
       setLogFileImpl(std::move(filename));
   }
   ALogger();
   ~ALogger();
 
   static ALogger& global();
 
   void setDebugMode(bool debug) {
       global().mDebug = debug;
   }
   bool isDebug() {
       return global().mDebug;
   }

   void setLogFile(APath path) {
       setLogFileImpl(std::move(path));
   }

   static void setLogFileForGlobal(APath path);
 
   [[nodiscard]]
   APath logFile() {
       return mLogFile.valueOrException().path();
   }
 
   void onLogged(std::function<void(const AString& prefix, const AString& message, Level level)> callback) {
       std::unique_lock lock(mOnLogged);
       mOnLogged = std::move(callback);
   }
   template <aui::invocable Callable>
   void doLogFileAccessSafe(Callable action) {
       std::unique_lock lock(mLogSync);
       ARaiiHelper opener = [&] {
           if (!mLogFile) return;
           try {
               mLogFile->open(true);
           } catch (const AException& e) {
               auto path = mLogFile->path();
               mLogFile.reset();
               lock.unlock();
               log(WARN, "Logger", fmt::format("Unable to reopen file {}: {}", path, e.getMessage()));
           }
       };
       if (!mLogFile || !mLogFile->nativeHandle()) {
           action();
           return;
       }
 
       mLogFile->close();
       action();
   }
 
   static LogWriter info(const AString& str)
   {
       return {global(), INFO, str};
   }
   static LogWriter warn(const AString& str)
   {
       return {global(), WARN, str};
   }
   static LogWriter err(const AString& str)
   {
       return {global(), ERR, str};
   }
   static LogWriter debug(const AString& str)
   {
       return {global(), DEBUG, str};
   }

   LogWriter log(Level level, const AString& prefix)
   {
       return {*this, level, prefix};
   }
 
 
private:
 
   AOptional<AFileOutputStream> mLogFile;
   AMutex mLogSync;
   AMutexWrapper<std::function<void(const AString& prefix, const AString& message, Level level)>> mOnLogged;
 
   bool mDebug = AUI_DEBUG;
 
   void setLogFileImpl(AString path);
 

   void log(Level level, std::string_view prefix, std::string_view message);
 
};
namespace glm {
   template<glm::length_t L, typename T, glm::qualifier Q>
   inline std::ostream& operator<<(std::ostream& o, vec<L, T, Q> vec) {
       o << "{ ";
       for (std::size_t i = 0; i < L; ++i) {
           if (i != 0) o << ", ";
           o << vec[i];
       }
       o << " }";
 
       return o;
   }
 
}
 
template<glm::length_t L, typename T, glm::qualifier Q>
struct fmt::formatter<glm::vec<L, T, Q>> {
   constexpr auto parse (format_parse_context& ctx) { return ctx.begin(); }
 
   template <typename Context>
   constexpr auto format(glm::vec<L, T, Q> vec, Context& ctx) const {
       auto out = ctx.out();
       out = format_to(out, FMT_STRING("{{ "));
       for (glm::length_t i = 0; i < L; ++i) {
           if (i == 0) {
               out = format_to(out, FMT_STRING("{}"), vec[i]);
           } else {
               out = format_to(out, FMT_STRING(", {}"), vec[i]);
           }
       }
       out = format_to(out, FMT_STRING(" }}"));
       return out;
   }
 
private:
};
 
#define ALOG_DEBUG(str) if (ALogger::global().isDebug()) ALogger::debug(str)
 
#include <AUI/Traits/strings.h>

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.