Logger.h

Go to the documentation of this file.

 
 
#ifndef __LOGGER__H__
#define __LOGGER__H__
 
#include <stdio.h>
#include <vector>
#include <string>
#include <stdlib.h>
#include <stdarg.h>
#include <chrono>
#include <stdexcept>
 
#include <iostream>
#include <fstream>
#include <sstream>
 
using namespace std;
 
#define LOG_APP      0
#define LOG_DEF      1
// InfraMed sections
#define LOG_INFRA    2
#define LOG_REP      3
#define LOG_INDEX    4
#define LOG_DICT     5
#define LOG_SIG      6
#define LOG_CONVERT  7
// MedUtils sections
#define LOG_MED_UTILS   8
#define LOG_MEDMAT   9
#define LOG_MEDIO    10
#define LOG_DATA_STRUCTURES 11
// MedAlgo sections
#define LOG_MEDALGO 12
// MedFeat sections
#define LOG_MEDFEAT 13
// MedStat sections
#define LOG_MEDSTAT 14
// RepCleaner section
#define LOG_REPCLEANER 15
// FtrGenerator section
#define LOG_FTRGNRTR 16
// CrossValidator section
#define LOG_CV 17
// FeatCleaner section
#define LOG_FEATCLEANER 18
// ValueCleaner section
#define LOG_VALCLNR 19
// MedSamples section
#define MED_SAMPLES_CV 20
// FeatsSelector section
#define LOG_FEAT_SELECTOR 21
// SampleFilter section
#define LOG_SMPL_FILTER 22
// SerializableObject section
#define LOG_SRL 23
// MedModel section
#define LOG_MED_MODEL 24
// RepositoryType section
#define LOG_REPTYPE 25
 
#define MAX_LOG_SECTION 26
 
 
 
#define NO_LOG_LEVEL        0
#define MIN_LOG_LEVEL       0
 
#define DEBUG_LOG_LEVEL     3
 
#define LOG_DEF_LEVEL       5
 
#define MAX_LOG_LEVEL       10
#define VERBOSE_LOG_LEVEL   10
 
 
extern vector<string> log_section_to_name;
extern vector<string> log_level_to_name;
 
class MedLogger {
public:
    vector<int> levels;
    vector<vector<FILE *>> fds; //each section can write to multipal buffers
    vector<vector<string>> file_names; // required to avoid multiple closing of same file
    FILE *out_fd;
    string out_file_name;
    vector<string> format; 
 
    MedLogger();
    ~MedLogger();
 
    void init_all_levels(int level);
    int init_all_files(const string &fname);
    void init_level(int section, int level);
    void init_file(int section, FILE *of);
    int init_file(int section, const string &fname);
    int add_file(int section, const string &fname);
 
    void init_out(); //default output (stdout)
    void init_out(FILE *of);
    void init_out(const string &fname);
 
    int log(int section, int print_level, const char *fmt, ...);
    void out(char *fmt, ...);
 
    void init_format(int section, const string &new_format);
 
    void init_all_formats(int section, const string &new_format);
};
 
extern MedLogger global_logger;
 
#define MEDLOG(Section,Level,fmt,...) global_logger.log(Section,Level,fmt, ##__VA_ARGS__)
#define MDBG(Level,fmt,...)  global_logger.log(LOCAL_SECTION,Level,fmt, ##__VA_ARGS__)
#define MLOG(fmt,...) global_logger.log(LOCAL_SECTION, LOCAL_LEVEL, fmt, ##__VA_ARGS__)
#define MLOG_V(fmt,...) global_logger.log(LOCAL_SECTION, VERBOSE_LOG_LEVEL, fmt, ##__VA_ARGS__)
#define MLOG_D(fmt,...) global_logger.log(LOCAL_SECTION, DEBUG_LOG_LEVEL, fmt, ##__VA_ARGS__)
#define MERR(fmt,...) global_logger.log(LOCAL_SECTION, MAX_LOG_LEVEL, fmt, ##__VA_ARGS__)
#define MWARN(fmt,...) global_logger.log(LOCAL_SECTION, MAX_LOG_LEVEL-1, fmt, ##__VA_ARGS__)
 
#define MOUT(fmt,...) global_logger.out(fmt, ##__VA_ARGS__)
 
#define MTHROW_AND_ERR_STR(fmt,...) {char buff[300];snprintf(buff, sizeof(buff), fmt, ##__VA_ARGS__);global_logger.log(LOCAL_SECTION, MAX_LOG_LEVEL, buff); throw runtime_error(string(buff));}
 
#define MTHROW_AND_ERR(fmt,...) {char buff[300];snprintf(buff, sizeof(buff), fmt, ##__VA_ARGS__);global_logger.log(LOCAL_SECTION,MAX_LOG_LEVEL,"RunTime ERROR: ");global_logger.log(LOCAL_SECTION, MAX_LOG_LEVEL, buff); throw std::runtime_error("Error");}
 
 
// next works and compiles also in H files
#define HMTHROW_AND_ERR(fmt,...) {char buff[300];snprintf(buff, sizeof(buff), fmt, ##__VA_ARGS__);global_logger.log(0, MAX_LOG_LEVEL, buff); throw runtime_error(string(buff));}
 
 
class MedTimer {
public:
    string name;
    chrono::high_resolution_clock::time_point t[2];
    unsigned long long diff;
 
    MedTimer(const string &tname) { name = tname; }
    MedTimer() { name = string(""); }
 
    void start() { t[0] = chrono::high_resolution_clock::now(); }
    void take_curr_time() { t[1] = chrono::high_resolution_clock::now(); diff = (unsigned long long)(chrono::duration_cast<chrono::microseconds>(t[1] - t[0]).count()); }
    unsigned long long get_clock_micro() {
        auto t_now = chrono::high_resolution_clock::now();
        auto micro = chrono::duration_cast<chrono::microseconds>(t_now.time_since_epoch());
        return (unsigned long long)(micro.count());
    }
 
    double diff_microsec() { return (double)diff; }
    double diff_milisec() { return (double)diff / 1000.0; }
    double diff_sec() { return (double)diff / 1000000.0; }
 
};
 
class MedProgress {
public:
    chrono::high_resolution_clock::time_point tm_start;
    chrono::high_resolution_clock::time_point tm_prog;
    int progress;
    int max_loop;
    int print_interval;
    string print_title;
    int max_threads;
    bool alway_print_total;
 
    int print_section;
    int print_level;
 
    MedProgress(const string &title, int mprocess_cnt, int print_inter = 30, int max_th = 50);
 
    void update();
 
    void skip_update();
 
    void update_no_check();
};
 
void get_current_time(string &time_str);
 
#endif