Logger.hpp

Go to the documentation of this file.

/*
   Copyright 2022 Rishi Challa
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
 
#pragma once
 
#include <fstream>
#include <string>
#include <string.h>
#include <mutex>
 
#ifdef KALE_DEBUG
 
#ifdef KALE_WINDOWS
#define TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES
#endif
 
#include <termcolor/termcolor.hpp>
#include <iostream>
 
#endif
 
namespace Kale {
 
    class Logger {
    private:
 
        // Colors for console in Debug Mode
        #ifdef KALE_DEBUG
 
        constexpr static auto rc = termcolor::reset;
        
        constexpr static auto tc = termcolor::color<87>;
        
        constexpr static auto lc = termcolor::color<249>;
        
        constexpr static auto ic = termcolor::color<116>;
        
        constexpr static auto wc = termcolor::color<220>;
        
        constexpr static auto ec = termcolor::color<198>;
        
        constexpr static auto fc = termcolor::color<85>;
        
        constexpr static auto lic = termcolor::color<86>;
        
        constexpr static auto dc = termcolor::color<241>;
 
        #endif
 
        std::ofstream logFile;
 
        std::mutex mutex;
 
        std::string getTimePrefix();
    
    protected:
 
        void load(const std::string& applicationName);
 
        friend class Application;
 
    public:
 
        Logger();
        
        Logger(const Logger& other) = delete;
        
        Logger(Logger&& other) = delete;
        
        void operator=(const Logger& other) = delete;
        
        void operator=(Logger&& other) = delete;
 
        template <typename T> void log(T msg) {
            std::string time = getTimePrefix();
 
            std::lock_guard<std::mutex> guard(mutex);
            #ifdef KALE_DEBUG
            std::cout << dc << "[" << tc << time << dc <<  "] " << // [HH:MM AM]
                lc << msg << "\n" << rc; // Msg
            #endif
 
            logFile << "[" << time << "] " << msg << std::endl;
        }
 
        template <typename T> void info(T msg) {
            std::string time = getTimePrefix();
 
            std::lock_guard<std::mutex> guard(mutex);
            #ifdef KALE_DEBUG
            std::cout << dc << "[" << tc << time << dc <<  "] [" << // [HH:MM AM]
                ic << "INFO" << dc << "] " << ic << msg << "\n" << rc; // [Info] Msg
            #endif
 
            logFile << "[" << time << "] " << "[INFO] " << msg << std::endl;
        }
 
        template <typename T> void warn(T msg) {
            std::string time = getTimePrefix();
 
            std::lock_guard<std::mutex> guard(mutex);
            #ifdef KALE_DEBUG
            std::cout << dc << "[" << tc << time << dc <<  "] [" << // [HH:MM AM]
                wc << "WARNING" << dc << "] " << wc << msg << "\n" << rc; // [Warning] Msg
            #endif
 
            logFile << "[" << time << "] " << "[WARNING] " << msg << std::endl;
        }
 
        template <typename T> void error(T msg) {
            std::string time = getTimePrefix();
 
            std::lock_guard<std::mutex> guard(mutex);
            #ifdef KALE_DEBUG
            std::cout << dc << "[" << tc << time << dc <<  "] [" << // [HH:MM AM]
                ec << "ERROR" << dc << "] " << ec << msg << "\n" << rc; // [Error] Msg
            #endif
 
            logFile << "[" << time << "] " << "[ERROR] " << msg << std::endl;
        }
 
        template <typename T> void log(unsigned int line, const char* file, T msg) {
            std::string time = getTimePrefix();
 
            std::lock_guard<std::mutex> guard(mutex);
            #ifdef KALE_DEBUG
            std::cout << dc << "[" << tc << time << dc <<  "] [" << // [HH:MM AM]
                fc << file << dc << ":" << lic << line << dc << "] " << // [File:Line]
                lc << msg << "\n" << rc; // Msg
            #endif
 
            logFile << "[" << time << "] " << "[" << file << ":" << line << "] " << msg << std::endl;
        }
 
        template <typename T> void info(unsigned int line, const char* file, T msg) {
            std::string time = getTimePrefix();
 
            std::lock_guard<std::mutex> guard(mutex);
            #ifdef KALE_DEBUG
            std::cout << dc << "[" << tc << time << dc <<  "] [" << // [HH:MM AM]
                fc << file << dc << ":" << lic << line << dc << "] [" << // [File:Line]
                ic << "INFO" << dc << "] " << // [Info]
                ic << msg << "\n" << rc; // Msg
            #endif
 
            logFile << "[" << time << "] " << "[" << file << ":" << line << "] " << "[INFO] " << msg << std::endl;
        }
 
        template <typename T> void warn(unsigned int line, const char* file, T msg) {
            std::string time = getTimePrefix();
 
            std::lock_guard<std::mutex> guard(mutex);
            #ifdef KALE_DEBUG
            std::cout << dc << "[" << tc << time << dc <<  "] [" << // [HH:MM AM]
                fc << file << dc << ":" << lic << line << dc << "] [" << // [File:Line]
                wc << "WARNING" << dc << "] " << // [Warning]
                wc << msg << "\n" << rc; // Msg
            #endif
 
            logFile << "[" << time << "] " << "[" << file << ":" << line << "] " << "[WARNING] " << msg << std::endl;
        }
 
        template <typename T> void error(unsigned int line, const char* file, T msg) {
            std::string time = getTimePrefix();
 
            std::lock_guard<std::mutex> guard(mutex);
            #ifdef KALE_DEBUG
            std::cout << dc << "[" << tc << time << dc <<  "] [" << // [HH:MM AM]
                fc << file << dc << ":" << lic << line << dc << "] [" << // [File:Line]
                ec << "ERROR" << dc << "] " << // [Error]
                ec << msg << "\n" << rc; // Msg
            #endif
 
            logFile << "[" << time << "] " << "[" << file << ":" << line << "] " << "[ERROR] " << msg << std::endl;
        }
 
        template <typename T> void assertCheck(unsigned int line, const char* file, T assertion) {
            if (assertion) return;
            error(line, file, "Assertion Failed");
        }
 
        template <typename T, typename STR> void assertCheck(unsigned int line, const char* file, T assertion, STR msg) {
            using namespace std::string_literals;
            if (assertion) return;
            error(line, file, "Assertion Failed - "s + msg);
        }
    };
 
    inline Logger console;
}
 
#ifdef KALE_WINDOWS
#define __FILENAME__ strrchr("\\" __FILE__, '\\') + 1
#else
#define __FILENAME__ strrchr("/" __FILE__, '/') + 1
#endif
 
#define klPrint(x) Kale::console.log(__LINE__, __FILENAME__, x)
 
#define klInfo(x) Kale::console.info(__LINE__, __FILENAME__, x)
 
#define klWarn(x) Kale::console.warn(__LINE__, __FILENAME__, x)
 
#define klError(x) Kale::console.error(__LINE__, __FILENAME__, x)
 
#define klAssert(x) Kale::console.assertCheck(__LINE__, __FILENAME__, x)
 
#define klAssertMsg(x, y) Kale::console.assertCheck(__LINE__, __FILENAME__, x, y)