Log.hh

 
#ifndef __RAT_Log__
#define __RAT_Log__
 
#include <TMap.h>
#include <TObjString.h>
#include <TObject.h>
 
#include <RAT/FatalError.hh>
#include <RAT/json.hh>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
 
#include "dprintf.hpp"
#include "fileio.hpp"
#include "multiio.hpp"
#include "string_utilities.hpp"
#include "stringio.hpp"
 
namespace RAT {
 
class Log {
 public:
  enum Level {
    WARN = 0,   
    INFO = 1,   
    DETAIL = 2, 
    DEBUG = 3   
  };
 
  static bool Init(std::string _filename, Level display = INFO, Level log = DETAIL);
 
  static int GetDisplayLevel() { return display_level; };
 
  static void SetDisplayLevel(Level level);
 
  static int GetLogLevel() { return log_level; };
 
  static void SetLogLevel(Level level);
 
  [[noreturn]] static void Die(std::string message, int return_code = 1);
 
  static void Assert(bool condition, std::string message, int return_code = 1);
 
  static const std::string GetLogBuffer();
 
  static void AddMacro(const std::string &contents) { macro += contents; };
  static const std::string &GetMacro() { return macro; };
 
  static void AddObject(const std::string &name, TObject *obj) {
    objects.push_back(std::pair<std::string, TObject *>(name, obj));
  };
 
  static std::vector<std::pair<std::string, TObject *>> GetObjects() { return objects; };
 
  static void SetDBTraceState(bool state = true) { enable_dbtrace = state; };
 
  static bool GetDBTraceState() { return enable_dbtrace; };
 
  inline static void TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                                   int value);
  inline static void TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                                   double value);
  inline static void TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                                   const std::string &value);
 
  inline static void TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                                   const std::vector<int> &value);
  inline static void TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                                   const std::vector<double> &value);
  inline static void TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                                   const std::vector<std::string> &value);
 
  inline static void TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                                   const json::Value &value);
 
  static TMap *GetDBTraceMap() { return dbtrace; };
 
 protected:
  Log();
 
  inline static void AddDBEntry(const std::string &key, const std::string &value);
 
  static void SetupIO();
 
  static void ClearOMText(omtext *out);
 
  static omtext *outstreams[4];
 
  static std::string filename; 
  static oftext logfile;       
  static int display_level;    
  static int log_level;        
  static std::string macro; 
  static bool enable_dbtrace; 
  static TMap *dbtrace;       
  static std::vector<std::pair<std::string, TObject *>> objects; 
};
 
extern omtext warn;
extern omtext info;
extern omtext detail;
extern omtext debug;
 
 
void Log::AddDBEntry(const std::string &key, const std::string &value) {
  if (enable_dbtrace && !dbtrace->FindObject(key.c_str()))
    dbtrace->Add(new TObjString(key.c_str()), new TObjString(value.c_str()));
}
 
// The parameter is type double so this can be used as a seed for
// to_ratdb_double_string()
inline std::string to_ratdb_float_string(double value) {
  if (value == 0.0)
    return std::string("0.0");
  else
    return ::to_string(value);
}
 
inline std::string to_ratdb_double_string(double value) {
  std::string str = to_ratdb_float_string(value);
  size_t pos = str.find("d");
  if (pos == std::string::npos) str += "d";
  return str;
}
 
inline std::string escape_ratdb_string(const std::string &value) {
  if (value.find("\"") != std::string::npos) Log::Die("RATDB Trace Eror: value string with quotes inside!");
  return "\"" + value + "\"";
}
 
void Log::TraceDBAccess(const std::string &table, const std::string &index, const std::string &field, int value) {
  AddDBEntry(table + "[" + index + "]." + field, ::to_string(value));
}
 
void Log::TraceDBAccess(const std::string &table, const std::string &index, const std::string &field, double value) {
  AddDBEntry(table + "[" + index + "]." + field, to_ratdb_double_string(value));
}
 
void Log::TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                        const std::string &value) {
  AddDBEntry(table + "[" + index + "]." + field, escape_ratdb_string(value));
}
 
void Log::TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                        const std::vector<int> &value) {
  std::string key = table + "[" + index + "]." + field;
  if (!enable_dbtrace || dbtrace->FindObject(key.c_str())) return;
 
  std::string str_value("[ ");
  for (unsigned i = 0; i < value.size(); i++) {
    str_value += ::to_string(value[i]) + ", ";
  }
  str_value += "]";
 
  AddDBEntry(key, str_value);
}
 
void Log::TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                        const std::vector<double> &value) {
  std::string key = table + "[" + index + "]." + field;
  if (!enable_dbtrace || dbtrace->FindObject(key.c_str())) return;
 
  std::string str_value("[ ");
  for (unsigned i = 0; i < value.size(); i++) {
    str_value += to_ratdb_double_string(value[i]) + ", ";
  }
  str_value += "]";
 
  AddDBEntry(key, str_value);
}
 
void Log::TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                        const std::vector<std::string> &value) {
  std::string key = table + "[" + index + "]." + field;
  if (!enable_dbtrace || dbtrace->FindObject(key.c_str())) return;
 
  std::string str_value("[ ");
  for (unsigned i = 0; i < value.size(); i++) {
    str_value += escape_ratdb_string(value[i]) + ", ";
  }
  str_value += "]";
 
  AddDBEntry(key, str_value);
}
 
void Log::TraceDBAccess(const std::string &table, const std::string &index, const std::string &field,
                        const json::Value &value) {
  std::string key = table + "[" + index + "]." + field;
  if (!enable_dbtrace || dbtrace->FindObject(key.c_str())) return;
 
  std::stringstream ss;
  json::Writer writer(ss);
  writer.putValue(value);
 
  AddDBEntry(key, ss.str());
}
 
}  // namespace RAT
 
#endif