tjlog.h

/***************************************************************************
                          tjlog.h  -  description
                             -------------------
    begin                : Fri Aug 2 2002
    copyright            : (C) 2001 by Thies H. Jochimsen
    email                : jochimse@cns.mpg.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"};



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

---