tjlog.h

/***************************************************************************
                          tjlog.h  -  description
                             -------------------
    begin                : Fri Aug 2 2002
    copyright            : (C) 2000-2021 by Thies H. Jochimsen
    email                : thies@jochimsen.de
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef TJLOG_H
#define TJLOG_H
 
#ifndef TJUTILS_CONFIG_H
#define TJUTILS_CONFIG_H
#include <tjutils/config.h>
#endif
 
#include <tjutils/tjutils.h>
#include <tjutils/tjstream.h>
#include <tjutils/tjhandler.h>
#include <tjutils/tjlabel.h>
#include <tjutils/tjstatic.h>
#include <tjutils/tjstring.h>
#include <tjutils/tjcstd.h>
 
#define MAX_COMPONENT_SIZE 10
#define MAX_LOG_STRINGSIZE 25
 
enum logPriority {                      noLog=0, errorLog,   warningLog,   infoLog,   significantDebug,   normalDebug,   verboseDebug, numof_log_priorities, ignoreArgument};
static const char* logPriorityLabel[]={"noLog", "errorLog", "warningLog", "infoLog", "significantDebug", "normalDebug", "verboseDebug"};
AVOID_CC_WARNING(logPriorityLabel)
 
 
struct LogMessage {
 
  logPriority level;
 
  STD_string comp;
 
  STD_string obj;
 
  STD_string func;
 
  STD_string txt;
 
 
  STD_string str(unsigned int maxwidth=0, bool include_comp=true) const;
};
 
 
typedef void (*tracefunction)(const LogMessage& msg);
 
 
void default_tracefunction(const LogMessage& msg);
 
 
 
// function pointer to get/set log levels in global map of logLevels
typedef logPriority (*log_component_fptr) (logPriority);
 
 
class LogBase : public virtual StaticHandler<LogBase> {
 
 public:
 
  LogBase() {}  // for LogBaseoc
 
  LogBase(const char* component, const char* object, const Labeled* labeledObject, const char* function)
    : compLabel(component), objLabel(object), namedObj(labeledObject), funcName(function) {}
 
  static void set_log_level(const char* compname, logPriority level);
 
  static void set_uniform_log_level(logPriority level);
 
#ifndef NO_CMDLINE
  static bool set_log_levels(int argc, char *argv[], bool trigger_error=true);
#endif
 
  static STD_string get_usage();
 
  // Functions to used by Log-component types
  static bool register_component(const char*,log_component_fptr);
  static void unregister_component(const char*);
 
  static const char* get_levels();
 
  static void set_levels(const char* str);
 
  static void set_log_output_function(tracefunction func);
 
 
  // functions to initialize/delete static members by the StaticHandler template class
  static void init_static();
  static void destroy_static();
 
 
 
 protected:
  friend class LogOneLine;
 
  // Cache only plain pointers for efficiency
  const char* compLabel;
  const char* objLabel;    // Cache either the string
  const Labeled* namedObj; // or the object to retrieve the label from
  const char* funcName;
 
 
  void flush_oneline(const STD_string& txt, logPriority level);
 
#ifndef NO_CMDLINE
  static void parse_log_cmdline_options(int argc, char *argv[], const char* opt, logPriority base);
#endif
 
 
  // global (singleton) data
  struct Global : public Labeled {
    Global() : tracefunc(default_tracefunction), uniform_init_level(ignoreArgument) {}
    tracefunction tracefunc;
    STD_map<STD_string,log_component_fptr> components;
    STD_map<STD_string,logPriority> init_level;
    logPriority uniform_init_level;
  };
 
  static SingletonHandler<Global,true> global; // Thread-safe singleton for global data
 
 
 private:
  friend class DebugDialog;
 
};
 
 
 
 
template<class C>
class Log : public virtual LogBase {
 
 public:
 
 
  Log(const char* objectLabel, const char* functionName, logPriority level=verboseDebug);
 
 
  Log(const Labeled* labeledObject, const char* functionName, logPriority level=verboseDebug);
 
 
  ~Log();
 
 
  static logPriority set_log_level(logPriority level); // to be called via log_component_fptr function pointer
  inline static logPriority get_log_level() {return logLevel;} // to be used by LogOneLine
 
 
 private:
 
  logPriority constrLevel;
 
  void register_comp();
 
  static logPriority logLevel;
  static bool registered; // call register_component only in 1st constructor
 
};
 
 
// Temporary object to log one line via ostringstream
// This ingenious technique was presented by Petru Marginean in Dr.Dobb's under the title 'Logging in C++'
struct LogOneLine {
 
 public:
  LogOneLine(LogBase& logobj, logPriority level) : log(logobj), lev(level) {}
 
  ~LogOneLine() {log.flush_oneline(oss.str(),lev);}
 
  STD_ostream& get_stream() {return oss;}
 
 private:
  LogBase& log;
  logPriority lev;
  STD_ostringstream oss;
};
 
 
// Min level which is included in release compilation
#define RELEASE_LOG_LEVEL infoLog
 
 
#ifdef ODIN_DEBUG
 
#define ODINLOG(logobj,level) \
if ((level) > (logobj).get_log_level()) ; \
else LogOneLine(logobj,level).get_stream()
 
#else
 
#define ODINLOG(logobj,level) \
if ((level) > RELEASE_LOG_LEVEL) ; \
else if ((level) > (logobj).get_log_level()) ; \
     else LogOneLine(logobj,level).get_stream()
 
#endif
 
 
#endif