Log.h

/*************************************************************************
 *
 * KINEMATICOUP CONFIDENTIAL
 * __________________
 *
 *  Copyright (2016-2021) KinematicSoup Technologies Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of KinematicSoup Technologies Incorporated and its
 * suppliers, if any.  The intellectual and technical concepts contained
 * herein are proprietary to KinematicSoup Technologies Incorporated
 * and its suppliers and may be covered by Canadian and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from KinematicSoup Technologies Incorporated.
 */
#pragma once
 
#include <ctime>
#include <chrono>
#include <cstring>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <ostream>
#include <string>
#include <unordered_map>
#include <vector>
#include <memory>
 
#include "Exports.h"
 
#ifdef _WIN32
  #define __cdecl
#else
  #define __cdecl __attribute__((__cdecl__))
#endif
 
#define AUTHENTICATION_CHANNEL "Authentication"
 
namespace KS {
    // Log Levels
    enum LogLevel:uint8_t
    {
        LOG_ALL     = 0xFF,
        LOG_FATAL   = 16,
        LOG_ERROR   = 8,
        LOG_WARNING = 4,
        LOG_INFO    = 2,
        LOG_DEBUG   = 1
    };
 
    typedef void(__cdecl *LogHandler)(LogLevel level, const char* channel, const char* message);
 
    class Log
    {
    public:
        EXTERNAL static std::shared_ptr<Log> Instance();
 
        EXTERNAL static void SetInstance(std::shared_ptr<Log> logPtr);
 
        EXTERNAL void RegisterCallback(const std::string& channel, LogHandler handler, uint8_t levels, bool allowBubbling);
 
        EXTERNAL void UnregisterCallback(const std::string& channel, LogHandler handler);
 
        EXTERNAL void Write(const std::string& message, const std::string& channel, LogLevel level);
 
        EXTERNAL static void Debug(const std::string& message, const std::string& channel = "Root");
 
        EXTERNAL static void Info(const std::string& message, const std::string& channel = "Root");
 
        EXTERNAL static void Warning(const std::string& message, const std::string& channel = "Root");
 
        EXTERNAL static void Error(const std::string& message, const std::string& channel = "Root");
 
        EXTERNAL static void Fatal(const std::string& message, const std::string& channel = "Root");
 
        EXTERNAL static std::string GetLevelString(LogLevel logLevel);
 
        EXTERNAL static std::string GetTimeString();
 
    private:
        static std::shared_ptr<Log> m_instancePtr;
 
        struct Logger
        {
            LogHandler handler;
            uint8_t levels;
            bool allowBubbling;
        };
 
        std::unordered_map<std::string, std::vector<Logger>> m_loggers;
 
        bool HandleLog(
            const std::string& message,
            const std::string& channel,
            LogLevel level,
            const std::string& handler);
    };
}