tklog.h

/********************************************************************************
 *   Copyright (c) : Université de Lyon 1, CNRS/IN2P3, UMR5822,                 *
 *                   IP2I, F-69622 Villeurbanne Cedex, France                   *
 *                   Normandie Université, ENSICAEN, UNICAEN, CNRS/IN2P3,       *
 *                   LPC Caen, F-14000 Caen, France                             *
 *   Contibutor(s) :                                                            *
 *      Jérémie Dudouet jeremie.dudouet@cnrs.fr [2020]                          *
 *      Diego Gruyer    diego.gruyer@cnrs.fr    [2020]                          *
 *                                                                              *
 *    This software is governed by the CeCILL-B license under French law and    *
 *    abiding by the  rules of distribution of free  software.  You can use,    *
 *    modify  and/ or  redistribute  the  software under  the  terms of  the    *
 *    CeCILL-B license as circulated by CEA, CNRS and INRIA at the following    *
 *    URL \"http://www.cecill.info\".                                           *
 *                                                                              *
 *    As a counterpart to the access  to the source code and rights to copy,    *
 *    modify  and redistribute granted  by the  license, users  are provided    *
 *    only with a limited warranty  and the software's author, the holder of    *
 *    the economic  rights, and the  successive licensors have  only limited    *
 *    liability.                                                                *
 *                                                                              *
 *    In this respect, the user's attention is drawn to the risks associated    *
 *    with loading,  using, modifying  and/or developing or  reproducing the    *
 *    software by the user in light of its specific status of free software,    *
 *    that  may mean that  it is  complicated to  manipulate, and  that also    *
 *    therefore  means that it  is reserved  for developers  and experienced    *
 *    professionals having in-depth  computer knowledge. Users are therefore    *
 *    encouraged  to load  and test  the software's  suitability  as regards    *
 *    their  requirements  in  conditions  enabling the  security  of  their    *
 *    systems  and/or data to  be ensured  and, more  generally, to  use and    *
 *    operate it in the same conditions as regards security.                    *
 *                                                                              *
 *    The fact that  you are presently reading this means  that you have had    *
 *    knowledge of the CeCILL-B license and that you accept its terms.          *
 ********************************************************************************/
 
#ifndef tklog_H
#define tklog_H
 
#include "tkn_config.h"
 
#ifdef HAS_ROOT
#include "TClass.h"
#endif
 
#include <iostream>
#include <sstream>
#include <mutex>
 
#include "tkstring.h"
 
namespace tkn {
 
class tklog{
 
    static std::recursive_mutex& get_mutex() {
        static std::recursive_mutex mutex;
        return mutex;
    }
 
    static thread_local tklog *g_log;
 
    bool fskiplog=false;
 
    friend tklog &do_endl(tklog &);   
    friend tklog &do_header(tklog &); 
    friend tklog &do_log(tklog &);    
    friend tklog &reset(tklog &);     
 
 
    friend tklog &skip_line(tklog &);
 
    friend tklog &info(tklog &);
    friend tklog &comment(tklog &);
    friend tklog &warning(tklog &);
    friend tklog &error(tklog &);
 
    friend tklog &info_o(tklog &);
    friend tklog &warning_o(tklog &);
    friend tklog &error_o(tklog &);
 
 
    friend tklog &info_v(tklog &);
    friend tklog &warning_v(tklog &);
    friend tklog &error_v(tklog &);
 
    friend tklog &debug(tklog &log);
    friend tklog &info_vo(tklog &);
    friend tklog &warning_vo(tklog &);
    friend tklog &error_vo(tklog &);
 
 
    friend tklog &high_intensity(tklog &);
 
    friend tklog &black(tklog &);
    friend tklog &red(tklog &);
    friend tklog &green(tklog &);
    friend tklog &yellow(tklog &);
    friend tklog &blue(tklog &);
    friend tklog &purple(tklog &);
    friend tklog &cyan(tklog &);
    friend tklog &white(tklog &);
 
    friend tklog &black_bg(tklog &);
    friend tklog &red_bg(tklog &);
    friend tklog &green_bg(tklog &);
    friend tklog &yellow_bg(tklog &);
    friend tklog &blue_bg(tklog &);
    friend tklog &purple_bg(tklog &);
    friend tklog &cyan_bg(tklog &);
    friend tklog &white_bg(tklog &);
 
    friend tklog &regular(tklog &);
    friend tklog &bold(tklog &);
    friend tklog &italic(tklog &);
    friend tklog &underline(tklog &);
    friend tklog &blink(tklog &);
 
public:
    enum log_level { kinfo, kwarning, kerror, knone};
 
    std::ostringstream fType_message{};             
    std::ostringstream fCore_message{};             
    std::ostringstream fHeader{};                   
    static const tkstring freset_font;              
 
    tkstring fClass{};
    tkstring fMethod{};
 
    enum bColor {
        kBlack         = 0,
        kRed           = 1,
        kGreen         = 2,
        kYellow        = 3,
        kBlue          = 4,
        kPurple        = 5,
        kCyan          = 6,
        kWhite         = 7,
        kDefault_color = 8,
    };
 
    enum bType {
        kRegular        = 0,
        kBold           = 1,
        kItalic         = 3,
        kUnderline      = 4,
        kBlink          = 5,
    };
 
    bColor fFG_color = kDefault_color;
    bColor fBG_color = kDefault_color;
    tkstring fTypes  = "";
    bool fHigh_intensity_colors = false;
 
    log_level flog_level = kinfo;
    bool fprint_warnings = true;
 
public:
    static tklog *the_log();
 
    tklog() {}
    virtual ~tklog() {}
 
    void set_class(tkstring _class_name) {fClass = _class_name;}
    void set_method(tkstring _method_name) {fMethod = _method_name;}
 
    void progress_bar(int _max, int _value, const tkstring &_message="");
 
    void set_log_level(log_level _level) {flog_level = _level;}
    void set_warnings(bool _print_warnings=true) {fprint_warnings = _print_warnings;}
 
    // Reset colors, and clear class and method name
    void clear() {fClass=""; fMethod="";reset();}
 
    virtual tklog & operator<< ( tklog &(*pf)(tklog&) )
    { (*pf)(*this); return (*this); }
 
    template<class T> tklog &operator<<(T t) {
        if(fskiplog) return (*this);
        fCore_message << t;
        return (*this);
    }
 
    tklog &operator<<(std::basic_ostream<char> o) {
        if(fskiplog) return (*this);
        std::lock_guard<std::recursive_mutex> lock(get_mutex());
        std::cout << &o;
        std::cout.flush();
        return (*this);
    }
 
private:
 
    void set_type(bType _type);
    void process_color();
    void reset();
 
#ifdef HAS_ROOT
    ClassDef(tklog,0);
#endif
};
 
inline tklog &do_header(tklog &log) {
    log.process_color();
    if(!log.fskiplog) {
        log.fType_message << log.fHeader.str() << log.fCore_message.str() << tklog::freset_font;
    }
    log.reset();
    log.fCore_message.str("");log.fCore_message.clear();
    return log;
}
 
inline tklog &do_log(tklog &log) {
    log.process_color();
    if(!log.fskiplog) {
        std::lock_guard<std::recursive_mutex> lock(log.get_mutex());
        std::cout << log.fType_message.str() << log.fHeader.str() << log.fCore_message.str() << tklog::freset_font;
        std::cout.flush();
    }
    log.reset();
    log.fCore_message.str("");log.fCore_message.clear();
    log.fType_message.str("");log.fType_message.clear();
    return log;
}
 
inline tklog &do_endl(tklog &log) {
    log.process_color();
    if(!log.fskiplog) {
        std::lock_guard<std::recursive_mutex> lock(log.get_mutex());
        std::cout << log.fType_message.str() << log.fHeader.str() << log.fCore_message.str() << tklog::freset_font;
        std::cout<<std::endl;
        std::cout.flush();
    }
    log.reset();
    log.fCore_message.str("");log.fCore_message.clear();
    log.fType_message.str("");log.fType_message.clear();
    return log;
}
 
inline tklog &reset(tklog &log) {
    log.reset(); return log;
}
 
 
inline tklog &high_intensity(tklog &log) {
    log.fHigh_intensity_colors = true; return log; }
 
inline tklog &black(tklog &log) {
    log.fFG_color = tklog::kBlack; return log; }
 
inline tklog &red(tklog &log) {
    log.fFG_color = tklog::kRed; return log; }
 
inline tklog &green(tklog &log) {
    log.fFG_color = tklog::kGreen; return log; }
 
inline tklog &yellow(tklog &log) {
    log.fFG_color = tklog::kYellow; return log; }
 
inline tklog &blue(tklog &log) {
    log.fFG_color = tklog::kBlue; return log; }
 
inline tklog &purple(tklog &log) {
    log.fFG_color = tklog::kPurple; return log; }
 
inline tklog &cyan(tklog &log) {
    log.fFG_color = tklog::kCyan; return log; }
 
inline tklog &white(tklog &log) {
    log.fFG_color = tklog::kWhite; return log; }
 
 
inline tklog &black_bg(tklog &log) {
    log.fBG_color = tklog::kBlack; return log; }
 
inline tklog &red_bg(tklog &log) {
    log.fBG_color = tklog::kRed; return log; }
 
inline tklog &green_bg(tklog &log) {
    log.fBG_color = tklog::kGreen; return log; }
 
inline tklog &yellow_bg(tklog &log) {
    log.fBG_color = tklog::kYellow; return log; }
 
inline tklog &blue_bg(tklog &log) {
    log.fBG_color = tklog::kBlue; return log; }
 
inline tklog &purple_bg(tklog &log) {
    log.fBG_color = tklog::kPurple; return log; }
 
inline tklog &cyan_bg(tklog &log) {
    log.fBG_color = tklog::kCyan; return log; }
 
inline tklog &white_bg(tklog &log) {
    log.fBG_color = tklog::kWhite; return log; }
 
 
inline tklog &regular(tklog &log) {
    log.set_type(tklog::kRegular); return log; }
 
inline tklog &bold(tklog &log) {
    log.set_type(tklog::kBold); return log; }
 
inline tklog &italic(tklog &log) {
    log.set_type(tklog::kItalic); return log; }
 
inline tklog &underline(tklog &log) {
    log.set_type(tklog::kUnderline); return log; }
 
inline tklog &blink(tklog &log) {
    log.set_type(tklog::kBlink); return log; }
 
 
inline tklog &skip_line(tklog &log) {
    log << "\n" << "             ";
    return log;
}
 
inline tklog &info_o(tklog &log) {
    if(log.flog_level>tklog::kinfo) {log.fskiplog = true; return  log;}
    log << high_intensity << white << blue_bg << underline << italic << bold << "\u2713 INFO     :" << do_header << " " << blue;
    return log;
}
inline tklog &info(tklog &log) {
    if(log.flog_level>tklog::kinfo) {log.fskiplog = true; return  log;}
    log << high_intensity << blue << bold << "[ INFO     ]" << do_header << " ";// << blue;
    return log;
}
 
inline tklog &comment(tklog &log) {
    if(log.flog_level>tklog::kinfo) {log.fskiplog = true; return  log;}
    log << high_intensity << green << bold <<"[ COMMENT  ]" << do_header << " ";
    return log;
}
 
inline tklog &warning_o(tklog &log) {
    if(!log.fprint_warnings) {log.fskiplog = true; return  log;}
    if(log.flog_level>tklog::kwarning) {log.fskiplog = true; return  log;}
    log << high_intensity << yellow_bg << underline << italic << bold << "\u26A0 WARNING  :" << do_header << " "  << yellow;
    return log;
}
inline tklog &warning(tklog &log) {
    if(!log.fprint_warnings) {log.fskiplog = true; return  log;}
    if(log.flog_level>tklog::kwarning) {log.fskiplog = true; return  log;}
    log << high_intensity << yellow << bold << "[ WARNING  ]" << do_header << " ";// << yellow;
    return log;
}
 
inline tklog &error_o(tklog &log) {
    if(log.flog_level>tklog::kerror) {log.fskiplog = true; return  log;}
    log << high_intensity << white << red_bg << underline << italic << bold << "\u2716 ERROR    :" << do_header << " " << red;
    return log;
}
 
inline tklog &error(tklog &log) {
    if(log.flog_level>tklog::kerror) {log.fskiplog = true; return  log;}
    log << high_intensity << red  << bold << "[ ERROR    ]" << do_header << " ";// << red;
    return log;
}
 
inline tklog &debug(tklog &log) {
    log << high_intensity << green  << bold << "[ DEBUG    ]" << do_header << " ";
    return log;
}
 
inline tklog &info_vo(tklog &log) {
    if(log.flog_level>tklog::kinfo) {log.fskiplog = true; return  log;}
    log << high_intensity << white << blue_bg << underline << italic << bold << "\u2713 INFO   :" << do_header << " " << blue;
    if(!log.fClass.is_empty() && !log.fMethod.is_empty()) {
        log << underline << log.fClass << "::" << log.fMethod << do_header;
    }
    log << "\n";
    return log;
}
 
inline tklog &info_v(tklog &log) {
    if(log.flog_level>tklog::kinfo) {log.fskiplog = true; return  log;}
    log << high_intensity << blue << bold << "[ INFO     ]" << do_header << " ";// << blue;
    if(!log.fClass.is_empty() && !log.fMethod.is_empty()) {
        log  << log.fClass << "::" << log.fMethod << do_header;
    }
    log << "\n             ";// << blue;
    return log;
}
 
inline tklog &warning_vo(tklog &log) {
    if(!log.fprint_warnings) {log.fskiplog = true; return  log;}
    if(log.flog_level>tklog::kwarning) {log.fskiplog = true; return  log;}
    log << high_intensity << yellow_bg << underline << italic << bold << "\u26A0 WARNING:" << do_header << " "  << yellow;
    if(!log.fClass.is_empty() && !log.fMethod.is_empty()) {
        log << underline << log.fClass << "::" << log.fMethod << do_header;
    }
    log << "\n";
    return log;
}
 
inline tklog &warning_v(tklog &log) {
    if(!log.fprint_warnings) {log.fskiplog = true; return  log;}
    if(log.flog_level>tklog::kwarning) {log.fskiplog = true; return  log;}
    log << high_intensity << yellow << bold << "[ WARNING  ]" << do_header << " ";//  << yellow;
    if(!log.fClass.is_empty() && !log.fMethod.is_empty()) {
        log  << log.fClass << "::" << log.fMethod << do_header;
    }
    log << "\n             ";// << yellow;
    return log;
}
 
inline tklog &error_vo(tklog &log) {
    if(log.flog_level>tklog::kerror) {log.fskiplog = true; return  log;}
    log << high_intensity << white << red_bg << underline << italic << bold << "\u2716 ERROR  :" << do_header << " " << red;
    if(!log.fClass.is_empty() && !log.fMethod.is_empty()) {
        log << underline << log.fClass << "::" << log.fMethod << do_header;
    }
    log << "\n";
    return log;
}
 
inline tklog &error_v(tklog &log) {
    if(log.flog_level>tklog::kerror) {log.fskiplog = true; return  log;}
    log  << high_intensity << red << bold << "[ ERROR    ]" << do_header << " ";// << red;
    if(!log.fClass.is_empty() && !log.fMethod.is_empty()) {
        log  << log.fClass << "::" << log.fMethod << do_header;
    }
    log << "\n             ";// << red;
    return log;
}
 
}
 
#define glog (*tkn::tklog::the_log())
 
#ifdef HAS_DEBUG
#define gdebug glog << debug
#else
#define gdebug if(0) glog << debug
#endif
 
#endif