sevnlog.h

Go to the documentation of this file.

//
// Created by Giuliano on 29/11/19.
// Header to store logging functions and definitions (mostly for debug)
//
 
#ifndef SEVN_SEVNLOG_H
#define SEVN_SEVNLOG_H
 
#ifdef _OPENMP
#include <omp.h>
#endif
 
#include <string>
#include <sstream>
#include <iostream>
#include "errhand.h"
 
 
//TODO Remove this and correctly use SevnLogging
//GI291119: Define the DEBUG_LOG functions to print the Debug message only if enable in the compilation
#ifdef DEBUG
#define DEBUG_LOG(str) do { std::cout <<  "DEBUG: FILE::" << __FILE__ << " LINE::"  <<__LINE__ << std::endl << " -> " << str << " <- " << std::endl; } while (false)
#else
#define DEBUG_LOG(str) do {  } while (false)
#endif
 
//TODO Add the possibility to directly flush the output in some log file(s).
//TODO It is really thread safe?
namespace sevnstd{
 
    class sevnerr;
 
    class SevnLogging {
 
    public:
 
        SevnLogging() {}
 
        //TODO Is ok for a single instance to modify the log_level. Is maybe better to modify only a local log_level and the use this in the various log function?
        SevnLogging(int level) {
            set_level(level);
        }
        ~SevnLogging() {}
 
        void log(int level, std::string errstate, const char *file_input = nullptr, int line_input = -1, int stop = 0)  const;
 
        void debug(std::string errstate, const char *file_input = nullptr, int line_input = -1)  const;
 
 
        void info(std::string errstate, const char *file_input = nullptr, int line_input = -1)  const;
 
 
        void warning(std::string errstate, const char *file_input = nullptr, int line_input = -1)  const;
 
        void error(std::string errstate, const char *file_input = nullptr, int line_input = -1, bool stop = true)  const;
 
        template<class E>
        void error(std::string errstate, const char *file_input = nullptr, int line_input = -1, bool stop = true, E&& err= nullptr)  const{
 
            #ifdef _OPENMP
                        int num_thread=omp_get_thread_num();
            #else
                        int num_thread=0;
            #endif
 
            std::ostringstream oss;
            oss << " LOG::ERROR (Thread " << num_thread << "): " << std::endl;
            oss << "   Message : " << errstate << std::endl;
            if (file_input)
                oss << " From file: " << std::string(file_input) << std::endl;
            if (line_input >= 0)
                oss << " From line: " << line_input << std::endl;
            std::string err_mess=oss.str();
            if (stop)
                throw err.istance(err_mess);
            else
                std::cerr << oss.str();
 
#ifdef _OPENMP
#pragma omp atomic
#endif
            count_error++;
        }
 
 
        void critical(std::string errstate, const char *file_input = nullptr, int line_input = -1) const;
 
 
        template<class E>
        void critical(std::string errstate, const char *file_input = nullptr, int line_input = -1, E&& err= nullptr) const{
 
            #ifdef _OPENMP
                        int num_thread=omp_get_thread_num();
            #else
                        int num_thread=0;
            #endif
 
            std::ostringstream oss;
            oss << " LOG::CRITICAL (Thread " << num_thread << "): " << std::endl;
            oss << "   Message : " << errstate << std::endl;
            if (file_input)
                oss << " From file: " << std::string(file_input) << std::endl;
            if (line_input >= 0)
                oss << " From line: " << line_input << std::endl;
            std::string err_mess=oss.str();
            throw err.istance(err_mess);
        }
 
 
 
 
        //debug
        void inline pdebug()  const {
 
            #ifdef _OPENMP
                        int num_thread=omp_get_thread_num();
            #else
                        int num_thread=0;
            #endif
 
            std::cout<<"\nLOG::DEBUG (Thread " << num_thread << ")"<< std::endl;
            #ifdef _OPENMP
            #pragma omp atomic
            #endif
            count_debug++;}
 
        template<typename T, typename... Tail>
        void pdebug(T head, Tail... tail)  const{
            if (_LOG_LEVEL::_debug>=log_level) {
                std::cout << head << " ";
                pdebug(tail...);
            }
        }
 
 
        //info
        void inline pinfo()  const {
 
            #ifdef _OPENMP
                        int num_thread=omp_get_thread_num();
            #else
                        int num_thread=0;
            #endif
 
            std::cout<<"\nLOG::INFO (Thread " << num_thread << ")"<< std::endl;
            #ifdef _OPENMP
            #pragma omp atomic
            #endif
            count_info++;}
 
        template<typename T, typename... Tail>
        void pinfo(T head, Tail... tail)  const {
            if (_LOG_LEVEL::_info>=log_level) {
                std::cout << head << " ";
                pinfo(tail...);
            }
        }
 
        //warning
        void inline pwarning()  const {
 
 
            #ifdef _OPENMP
                        int num_thread=omp_get_thread_num();
            #else
                        int num_thread=0;
            #endif
 
            std::cerr<<"\nLOG::WARNING (Thread " << num_thread << ")"<< std::endl;
            #ifdef _OPENMP
            #pragma omp atomic
            #endif
            count_warning++;
        }
 
        template<typename T, typename... Tail>
        void pwarning(T head, Tail... tail)  const {
            //if (_LOG_LEVEL::_warning>=log_level and count_warning<=MAX_N_WARNING) {
            if (_LOG_LEVEL::_warning>=log_level) {
                std::cerr << head << " ";
                pwarning(tail...);
            }
        }
 
 
/*        *//*
        template<typename... Args>
        void pdebug(Args... args){
            if (_LOG_LEVEL::_debug>=log_level){
                std::cout << " LOG::DEBUG (Thread " << omp_get_thread_num() << "): " << std::endl;
                std::cout << "  Message:";
                ((std::cout << " "<<args), ...);
                #pragma omp atomic
                count_debug++;
            }
        }
 
        *//*
        template<typename... Args>
        void pinfo(Args... args){
            if (_LOG_LEVEL::_info>=log_level){
                std::cout << " LOG::INFO (Thread " << omp_get_thread_num() << "): " << std::endl;
                std::cout << "  Message:";
                ((std::cout << " "<<args), ...);
                #pragma omp atomic
                count_info++;
            }
        }*/
 
 
 
 
 
 
        inline int get_level() { return log_level;};
 
        inline unsigned  int get_Ndebug() { return count_debug;};
        inline unsigned  int get_Ninfo() { return count_info;};
        inline unsigned  int get_Nwarning() { return count_warning;};
        inline unsigned  int get_Nerror() { return count_error;};
        inline unsigned  int get_Ncustom() { return count_custom_log;};
 
        void set_level(std::string level);
 
    protected:
 
 
        enum _LOG_LEVEL {
            _notset = 0,       
            _debug = 10,       
            _info = 20,        
            _warning = 30,     
            _error = 40,       
            _critical = 100,   
        };
 
        //const unsigned int MAX_N_WARNING=10;
 
        inline void set_level(int level) {log_level=level;};
 
 
 
        static int log_level;    
        //GI This counter should be thread safe because each update is proteceted by the openmp atomic directive.
        static unsigned int count_debug;  
        static unsigned int count_info;   
        static unsigned int count_warning; 
        static unsigned int count_error;     
        static unsigned int count_custom_log;   
        //NB the critical has not a counter since it always throws an exception, so we cannot have more than one call at runtime.
    };
 
 
}
 
 
 
#endif //SEVN_SEVNLOG_H