Implementation of the base error system for gp-engine

.clang-format

@@ -162,7 +162,7 @@ MaxEmptyLinesToKeep: 1
 MainIncludeChar: Any
 LineEnding: CRLF
 Language: Cpp
-LambdaBodyIndentation: Signature
+LambdaBodyIndentation: OuterScope
 KeepEmptyLines:
   AtEndOfFile: true
   AtStartOfBlock: false

source/launch/editor/private/Main.cpp

@@ -3,18 +3,49 @@
 // mailto:support AT graphical-playground DOT com
 
 #include "container/BasicString.hpp"
-#include "container/BasicStringView.hpp"
 #include "container/Forward.hpp"
-#include "CoreMinimal.hpp"
+#include "errors/Error.hpp"
+#include "errors/ErrorConfig.hpp"
+#include "errors/ErrorRegistry.hpp"
+#include "errors/ErrorSystem.hpp"
 #include <iostream>
 
-int main()
+int main(int argc, char* argv[])
 {
     std::cout << "Hello, Graphical Playground Editor!" << std::endl;
     // TODO: Implement editor main function.
 
     gp::String str = "Hello, World!";
     std::cout << "gp::String says: " << str << std::endl;
 
+    auto& registry = gp::error::ErrorRegistry::instance();
+    std::cout << registry.dumpAll() << std::endl;
+
+    gp::error::ErrorSystemConfig config = gp::error::ErrorSystemConfig::getDevelopmentConfig();
+    config.abort.abortFrom = gp::error::Severity::Critical;
+    gp::error::ErrorSystem::initialize(config);
+
+    gp::Vector<gp::StringView> args;
+    for (int i = 0; i < argc; ++i)
+    {
+        args.pushBack(argv[i]);
+    }
+
+    for (const auto& arg: args)
+    {
+        // clang-format off
+        if (arg == "--trace") GP_TRACE("This is a trace message!");
+        else if (arg == "--debug") GP_DEBUG("This is a debug message!");
+        else if (arg == "--info") GP_INFO("This is an info message!");
+        else if (arg == "--warn") GP_WARN("This is a warning message!");
+        else if (arg == "--error") GP_ERROR("This is an error message!");
+        else if (arg == "--fatal") GP_FATAL("This is a fatal message!");
+        else if (arg == "--panic") GP_PANIC("This is a critical message!");
+        // clang-format on
+    }
+
+    gp::error::ErrorSystem::flushAll();
+    gp::error::ErrorSystem::shutdown();
+
     return 0;
 }

source/runtime/core/private/errors/ErrorContext.cpp

@@ -0,0 +1,96 @@
+// Copyright (c) - Graphical Playground. All rights reserved.
+// For more information, see https://graphical-playground/legal
+// mailto:support AT graphical-playground DOT com
+
+#include "errors/ErrorContext.hpp"
+#include "CoreMinimal.hpp"
+
+namespace gp::error
+{
+
+void ErrorContext::push(gp::String subsystem, gp::String operation)
+{
+    m_stack.pushBack({ std::move(subsystem), std::move(operation), {} });
+}
+
+void ErrorContext::pop() noexcept
+{
+    if (!m_stack.isEmpty())
+    {
+        m_stack.popBack();
+    }
+}
+
+void ErrorContext::tag(gp::String key, gp::String value)
+{
+    if (!m_stack.isEmpty())
+    {
+        m_stack.back().tags.pushBack({ std::move(key), std::move(value) });
+    }
+}
+
+GP_NODISCARD bool ErrorContext::isEmpty() const noexcept
+{
+    return m_stack.isEmpty();
+}
+
+GP_NODISCARD gp::USize ErrorContext::depth() const noexcept
+{
+    return m_stack.size();
+}
+
+GP_NODISCARD const gp::Vector<ContextFrame>& ErrorContext::frames() const noexcept
+{
+    return m_stack;
+}
+
+GP_NODISCARD gp::StringView ErrorContext::currentSubsystem() const noexcept
+{
+    return m_stack.isEmpty() ? gp::StringView{} : m_stack.back().subsystem.asView();
+}
+
+GP_NODISCARD MetaBag ErrorContext::flatten() const
+{
+    MetaBag out;
+
+    for (gp::USize i = 0; i < m_stack.size(); ++i)
+    {
+        const auto& frame = m_stack[i];
+        out.pushBack({ gp::String::format("scope[{}].subsystem", i), frame.subsystem });
+        out.pushBack({ gp::String::format("scope[{}].operation", i), frame.operation });
+        for (const auto& tag: frame.tags)
+        {
+            out.pushBack({ gp::String::format("scope[{}].{}", i, tag.key), tag.value });
+        }
+    }
+
+    return out;
+}
+
+void ErrorContext::setThreadName(gp::String name)
+{
+    m_threadName = std::move(name);
+}
+
+GP_NODISCARD const gp::String& ErrorContext::threadName() const noexcept
+{
+    return m_threadName;
+}
+
+ContextScope::ContextScope(gp::String subsystem, gp::String operation)
+{
+    ErrorContext::current().push(std::move(subsystem), std::move(operation));
+}
+
+ContextScope::~ContextScope() noexcept
+{
+    ErrorContext::current().pop();
+}
+
+ContextScope& ContextScope::tag(gp::String key, gp::String value)
+{
+    ErrorContext::current().tag(std::move(key), std::move(value));
+    return *this;
+}
+
+}   // namespace gp::error

source/runtime/core/private/errors/ErrorRecord.cpp

@@ -0,0 +1,133 @@
+// Copyright (c) - Graphical Playground. All rights reserved.
+// For more information, see https://graphical-playground/legal
+// mailto:support AT graphical-playground DOT com
+
+#include "errors/ErrorRecord.hpp"
+#include "errors/ErrorCode.hpp"
+#include "errors/ErrorSeverity.hpp"
+#include <ctime>
+#include <functional>
+
+namespace gp::error
+{
+
+void ErrorRecord::addMetadata(gp::String key, gp::String value)
+{
+    metadata.pushBack({ std::move(key), std::move(value) });
+}
+
+GP_NODISCARD gp::StringView ErrorRecord::getMetadata(gp::StringView key) const noexcept
+{
+    for (const auto& entry: metadata)
+    {
+        if (entry.key == key)
+        {
+            return entry.value;
+        }
+    }
+    return {};
+}
+
+GP_NODISCARD bool ErrorRecord::hasCause() const noexcept
+{
+    return cause != nullptr;
+}
+
+GP_NODISCARD gp::USize ErrorRecord::causeDepth() const noexcept
+{
+    gp::USize depth = 0;
+    const ErrorRecord* current = cause.get();
+    while (current)
+    {
+        ++depth;
+        current = current->cause.get();
+    }
+    return depth;
+}
+
+GP_NODISCARD gp::String ErrorRecord::summary() const
+{
+    return gp::String::format(
+        "[{}][{}:0x{:04X}] {}  ({}:{})",
+        getSeverityName(severity),
+        getDomainName(code.domain()),
+        code.code(),
+        message,
+        location.file_name(),
+        location.line()
+    );
+}
+
+GP_NODISCARD gp::String ErrorRecord::fullReport() const
+{
+    gp::String out;
+    out.reserve(2048);
+
+    out += "╔══ GP ErrorRecord ═══════════════════════════════════════════╗\n";
+    out += gp::String::format("║  Severity  : {}\n", getSeverityDisplay(severity));
+    out += gp::String::format("║  Code      : [{}] 0x{:04X}\n", getDomainName(code.domain()), code.code());
+    out += gp::String::format("║  Message   : {}\n", message);
+    out += gp::String::format(
+        "║  Location  : {}:{} in {}\n", location.file_name(), location.line(), location.function_name()
+    );
+    out += gp::String::format(
+        "║  Thread    : {} ({})\n",
+        threadName.isEmpty() ? "unnamed" : threadName,
+        [&]
+    {
+        auto id = threadId;
+        std::hash<std::thread::id> hashThreadId;
+        return gp::String::format("{:#x}", hashThreadId(id));
+    }()
+    );
+
+    auto tt = std::chrono::system_clock::to_time_t(wallTime);
+    char tbuf[64]{};
+    struct tm tm{};
+#if defined(_MSC_VER)
+    gmtime_s(&tm, &tt);
+#else
+    gmtime_r(&tt, &tm);
+#endif
+    strftime(tbuf, sizeof tbuf, "%Y-%m-%d %T UTC", &tm);
+    out += gp::String::format("║  Timestamp : {}\n", tbuf);
+
+    if (!metadata.isEmpty())
+    {
+        out += "║  Meta      :\n";
+        for (const auto& m: metadata)
+        {
+            out += gp::String::format("║    {}  =  {}\n", m.key, m.value);
+        }
+    }
+
+#if GP_HAS_STACKTRACE
+    if (!stacktrace.empty())
+    {
+        out += "║  Stacktrace:\n";
+        for (const auto& frame: stacktrace)
+        {
+            out += gp::String::format("║    {}\n", std::to_string(frame));
+        }
+    }
+#endif
+
+    if (hasCause())
+    {
+        out += "║  Caused by :\n";
+        const ErrorRecord* c = cause.get();
+        int depth = 0;
+        while (c && depth < 8)
+        {
+            out += gp::String::format("║    [{}] {}\n", getSeverityName(c->severity), c->message);
+            c = c->cause.get();
+            ++depth;
+        }
+    }
+
+    out += "╚══════════════════════════════════════════════════════════════╝\n";
+
+    return out;
+}
+
+}   // namespace gp::error