Logging.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <fstream>
#include <string>
#include <mutex>
 
#include "../Time.h"
#include "../Utils/Console.h"
 
namespace Gorgon { namespace Utils {
    
    class Logger {
        friend class helper;
        std::mutex mtx;
        
        class helper {
            friend class Logger;
            
            Logger *parent;
            int shift = 0;
            bool extraenter = false;
            
            helper() : parent(nullptr) { }
            
            helper(Logger *parent, int shift, bool extraenter) : parent(parent), shift(shift), extraenter(extraenter) {
                if(!parent) return;
                parent->mtx.lock();
            }
            
            helper(helper &&h) {
                parent=h.parent;
                shift=h.shift;
                extraenter=h.extraenter;
                
                h.parent=nullptr;
            }
            
            helper &operator =(helper &&h) {
                if(parent)
                    parent->mtx.unlock();
                
                parent=h.parent;
                shift=h.shift;
                extraenter=h.extraenter;
                
                h.parent=nullptr;
                
                return *this;
            }
            
        public:         
            ~helper() {
                if(!parent) return;
                    
                parent->mtx.unlock();
                
                if(extraenter)
                    (*parent->stream) << "\n";
                
                (*parent->stream)<<std::endl;
 
                if(parent->IsColorFunctional())
                    parent->reset(*parent->stream);
            }
            
            using endl_t = decltype(&std::endl<char, std::char_traits<char>>);
 
            helper &operator <<(const endl_t &) {
                if(!parent) return *this;
                
                (*parent->stream) << std::endl << std::string(shift, ' ');
                
                extraenter=true;
                
#ifndef NDEBUG
                if(!(*parent->stream)) {
                    throw std::runtime_error("Logging failed");
                }
#endif
                
                return *this;
            }
            
            template <class T_>
            helper &operator <<(const T_ &v) {
                if(!parent) return *this;
                
                (*parent->stream) << v;
                
#ifndef NDEBUG
                if(!(*parent->stream)) {
                    throw std::runtime_error("Logging failed");
                }
#endif
                
                return *this;
            }
        };
        
    public:
        enum State {
            Message,
            Error,
            Notice,
            Success
        };
        
        Logger(const std::string &section = "", bool marktime = true, bool markdate = false) : 
            section(section), marktime(marktime), markdate(markdate) 
        { }
 
        Logger(const char *section, bool marktime = true, bool markdate = false) : 
            Logger(std::string(section), marktime, markdate) 
        { }
        
        Logger(bool marktime, bool markdate = false) : Logger("", marktime, markdate) { }
        
        Logger(std::ostream &stream, const std::string &section = "", bool marktime = true, bool markdate = false) : 
            stream(&stream), section(section), marktime(marktime), markdate(markdate)
        { 
            
        }
 
        ~Logger() {
            CleanUp();
        }
 
        void InitializeConsole() {
            CleanUp();
            stream=&std::cout;
            owner=false;
            console = StdConsole();
        }
 
        void InitializeStream(std::ostream &stream) {
#ifndef NO_LOGGING
            CleanUp();
            this->stream=&stream;
            owner=false;
#endif
        }
 
        void InitializeFile(const std::string &filename) {
#ifndef NO_LOGGING
            CleanUp();
            stream=new std::ofstream(filename);
            owner=true;
#endif
        }
 
        void CleanUp() {
            if(owner) {
                delete stream;
            }
            
            stream    = nullptr;
            console   = Console();
        }
        
        void SetWidth(int width) {
            this->width = width;
        }
        
        template <class T_>
        helper operator <<(const T_ &v) {
            return Log(v, Message);
        }
        
        template <class T_>
        helper Log(const T_ &v, State state = Error) {
#ifndef NO_LOGGING
            if(!this->stream) return {nullptr, 0, false};
            auto &stream = *this->stream;
            
            int headw = marktime * 8 + markdate * 10 + (markdate && marktime) * 1 + ((markdate || marktime) && !section.empty()) * 1 + (int)section.size();
            
            if(headw) headw += 2;
 
            helper h;
            
            if(width && headw*1.25 >= width) {
                stream<<std::endl;
                
                h = {this, 4, true};
            }
            else if(headw) {                
                h = {this, headw, false};
            }
            else {
                h = {this, 0, true};
            }
            
            if(marktime || markdate) {
                auto dt = Time::Date::Now();
                
                if(markdate) {
                    if(IsColorFunctional())
                        console.SetColor(Console::Color::Cyan);
                        
                    stream<<dt.ISODate();
                    
                    if(marktime) stream<<" ";
                }
                
                if(marktime) {
                    stream<<dt.Time();
                }
                
                if(!section.empty()) stream<<" ";
            }
            
            if(IsColorFunctional()) {
                reset(stream);
                console.SetBold(true);
                colorize(state);
            }
            
            if(!section.empty()) stream<<section;
            
            if(headw) stream<<"  ";
 
            if(IsColorFunctional())
                reset(stream);
            
            if(state != Message) {
                if(IsColorFunctional()) {
                    colorize(state);
                }
                else {
                    stream << (state == Error ? "Error! : " : "Success: ");
                }
            }
            
            return std::move(h << v);
#else
            return {nullptr, 0, false};
#endif
        }
 
        void SetSection(const std::string &value) {
            section = value;
        }
        
        std::string GetSection() const {
            return section;
        }
        
        void SetMarkTime(bool value) {
            marktime = value;
        }
        
        bool GetMarkTime() const {
            return marktime;
        }
        
        void SetMarkDate(bool value) {
            markdate = value;
        }
        
        bool GetMarkDate() const {
            return markdate;
        }
        
        void EnableColor() {
            color = true;
        }
        
        
        void DisableColor() {
            color = false;
        }
        
        void SetColorEnabled(bool value) {
            color = value;
        }
        
        bool IsColorEnabled() const {
            return color;
        }
        
        bool IsColorFunctional() const {
            return color && hasconsole && console.IsColorSupported();
        }
        
        
    protected:
        
        void reset(std::ostream &stream) {
            if(console)
                console.Reset();
        }
 
        Console console;
        
        std::ostream *stream  = nullptr;
        bool owner            = false;
        
        bool marktime         = true;
        bool markdate         = true;
        
        bool hasconsole       = false;
        bool color            = true;
        int  width            = 0;
        
        std::string section;
        
    private:
        void colorize(State state) {
            switch(state) {
                case Message: /*do nothing*/                            break;
                case Error:   console.SetColor(Console::Color::Red );   break;
                case Notice:  console.SetColor(Console::Color::Yellow); break;
                case Success: console.SetColor(Console::Color::Green);  break;
                default:      console.SetColor(Console::Color::White);  break;
            }
        }
    };
 
#ifdef NDEBUG
#   define DEBUGONLY(action) 
#else   
#   define DEBUGONLY(action) action
#endif
 
} }