Merge pull request #6 from chriskari/upload-artifacts

Add bsc_karidas

1 files changed, 139 insertions, 0 deletions

diff --git a/archive/2025/summer/bsc_karidas/src/Logger.cpp b/archive/2025/summer/bsc_karidas/src/Logger.cpp
new file mode 100644
index 000000000..5db75f303
--- /dev/null
+++ b/archive/2025/summer/bsc_karidas/src/Logger.cpp
@@ -0,0 +1,139 @@
+#include "Logger.hpp"
+#include "QueueItem.hpp"
+#include <iostream>
+
+// Initialize static members
+std::unique_ptr<Logger> Logger::s_instance = nullptr;
+std::mutex Logger::s_instanceMutex;
+
+Logger &Logger::getInstance()
+{
+    std::lock_guard<std::mutex> lock(s_instanceMutex);
+    if (s_instance == nullptr)
+    {
+        s_instance.reset(new Logger());
+    }
+    return *s_instance;
+}
+
+Logger::Logger()
+    : m_logQueue(nullptr),
+      m_appendTimeout(std::chrono::milliseconds::max()),
+      m_initialized(false)
+{
+}
+
+Logger::~Logger()
+{
+    if (m_initialized)
+    {
+        reset();
+    }
+}
+
+bool Logger::initialize(std::shared_ptr<BufferQueue> queue,
+                        std::chrono::milliseconds appendTimeout)
+{
+    if (m_initialized)
+    {
+        reportError("Logger already initialized");
+        return false;
+    }
+
+    if (!queue)
+    {
+        reportError("Cannot initialize with a null queue");
+        return false;
+    }
+
+    m_logQueue = std::move(queue);
+    m_appendTimeout = appendTimeout;
+    m_initialized = true;
+
+    return true;
+}
+
+BufferQueue::ProducerToken Logger::createProducerToken()
+{
+    if (!m_initialized)
+    {
+        reportError("Logger not initialized");
+        throw std::runtime_error("Logger not initialized");
+    }
+
+    return m_logQueue->createProducerToken();
+}
+
+bool Logger::append(LogEntry entry,
+                    BufferQueue::ProducerToken &token,
+                    const std::optional<std::string> &filename)
+{
+    if (!m_initialized)
+    {
+        reportError("Logger not initialized");
+        return false;
+    }
+
+    QueueItem item{std::move(entry), filename};
+    return m_logQueue->enqueueBlocking(std::move(item), token, m_appendTimeout);
+}
+
+bool Logger::appendBatch(std::vector<LogEntry> entries,
+                         BufferQueue::ProducerToken &token,
+                         const std::optional<std::string> &filename)
+{
+    if (!m_initialized)
+    {
+        reportError("Logger not initialized");
+        return false;
+    }
+
+    if (entries.empty())
+    {
+        return true;
+    }
+
+    std::vector<QueueItem> batch;
+    batch.reserve(entries.size());
+    for (auto &entry : entries)
+    {
+        batch.emplace_back(std::move(entry), filename);
+    }
+    return m_logQueue->enqueueBatchBlocking(std::move(batch), token, m_appendTimeout);
+}
+
+bool Logger::reset()
+{
+    if (!m_initialized)
+    {
+        return false;
+    }
+
+    // Reset state
+    m_initialized = false;
+    m_logQueue.reset();
+
+    return true;
+}
+
+bool Logger::exportLogs(
+    const std::string &outputPath,
+    std::chrono::system_clock::time_point fromTimestamp,
+    std::chrono::system_clock::time_point toTimestamp)
+{
+    if (!m_initialized)
+    {
+        reportError("Logger not initialized");
+        return false;
+    }
+
+    // This functionality would typically be handled by a separate component,
+    // such as a log storage or retrieval system
+    reportError("Export logs functionality not implemented in Logger");
+    return false;
+}
+
+void Logger::reportError(const std::string &message)
+{
+    std::cerr << "Logger Error: " << message << std::endl;
+}
\ No newline at end of file