log.hh

/*
** TowBowlTactics, an adaptation of the tabletop game Blood Bowl.
**
** Copyright (C) 2006 The TBT Team.
**
** 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.
**
** The complete GNU General Public Licence Notice can be found as the
** `NOTICE' file in the root directory.
**
** The TBT Team consists of people listed in the `AUTHORS' file.
*/

#ifndef LOG_HH_
# define LOG_HH_

# include <cassert>
# include <iostream>
# include "misc/compose.hpp"

class Log
{
public:
  Log(int verbose_level = 1, const char* suffix = NULL);
  ~Log();

  void setVerboseLevel(int level);
  void setVerboseMask(int mask);
  void setModuleSuffix(const char* name);
  void setPrintLoc(bool enable = true);
  void setUseColor(bool enable = true);

  static Log* getInst();
  std::ostream& getStream();

  // Don't use them directly !
  static pthread_mutex_t lock_;
  int verbose_mask_;
  bool print_loc_;
  bool use_color_;
  char modsuffix_[64];

private:
  pthread_t pth_id_;
  char orig_modsuffix_[32];

  typedef std::map<pthread_t, Log*> ThreadList;
  static ThreadList thread_list_;
  static int ref_count_;
};

inline Log* Log::getInst()
{
  // If this assert breaks, you probably not have a Log object instancied.
  ThreadList::iterator it = thread_list_.find(pthread_self());
  assert(it != thread_list_.end());
  return it->second;
}

inline std::ostream& Log::getStream()
{
  return std::cerr;
}


// Set default MODULE_NAME and MODULE_COLOR, in case they are not provided.
# ifndef MODULE_NAME
#  define MODULE_NAME "unset"
# endif
# ifdef MODULE_COLOR
#  define C_NONE        "\e[0m"
#  define C_RED         "\e[1;31m"
#  define C_GREEN       "\e[1;32m"
#  define C_BROWN       "\e[1;33m"
#  define C_BLUE        "\e[1;34m"
#  define C_PURPLE      "\e[1;35m"
#  define C_CYAN        "\e[1;36m"
#  define C_GRAY        "\e[0;30m"
#  define C_BRED        "\e[0;31m"
#  define C_BGREEN      "\e[0;32m"
#  define C_YELLOW      "\e[0;33m"
#  define C_BBLUE       "\e[0;34m"
#  define C_BPURPLE     "\e[0;35m"
#  define C_BCYAN       "\e[0;36m"
# else
#  define MODULE_COLOR  ""
#  define C_NONE        ""
#  define C_RED         ""
#  define C_GREEN       ""
#  define C_BROWN       ""
#  define C_BLUE        ""
#  define C_PURPLE      ""
#  define C_CYAN        ""
#  define C_GRAY        ""
#  define C_BRED        ""
#  define C_BGREEN      ""
#  define C_YELLOW      ""
#  define C_BBLUE       ""
#  define C_BPURPLE     ""
#  define C_BCYAN       ""
# endif

// Do not use it. Prefer the ERR, WARN, and LOG? macros
# define LOG(Level, Msg)                                                        \
do {                                                                            \
  Log* l__ = Log::getInst();                                                    \
  if (l__->verbose_mask_ & (1 << Level)) {                                      \
    pthread_mutex_lock(&Log::lock_);                                            \
    std::ostringstream os__;                                                    \
    if (Level == 0)                                                             \
      if (l__->use_color_)                                                      \
        os__ << C_BRED "Error: " C_NONE;                                        \
      else                                                                      \
        os__ << "Error: ";                                                      \
    else if (Level == 1)                                                        \
      if (l__->use_color_)                                                      \
        os__ << C_YELLOW "Warning: " C_NONE;                                    \
      else                                                                      \
        os__ << "Warning: ";                                                    \
    os__ << Msg;                                                                \
    if (l__->print_loc_)                                                        \
      if (l__->use_color_)                                                      \
        l__->getStream() << "[" MODULE_COLOR MODULE_NAME << l__->modsuffix_     \
                       << C_NONE "] " << __FILE__ << ":" << __LINE__ << ": "    \
                       << os__.str() << std::endl;                              \
      else                                                                      \
        l__->getStream() << "[" MODULE_NAME << l__->modsuffix_                  \
                       << "] " << __FILE__ << ":" << __LINE__ << ": "           \
                       << os__.str() << std::endl;                              \
    else                                                                        \
      if (l__->use_color_)                                                      \
        l__->getStream() << "[" MODULE_COLOR MODULE_NAME << l__->modsuffix_     \
                       << C_NONE "] " << os__.str() << std::endl;               \
      else                                                                      \
        l__->getStream() << "[" MODULE_NAME << l__->modsuffix_                  \
                       << "] " << os__.str() << std::endl;                      \
    pthread_mutex_unlock(&Log::lock_);                                          \
  }                                                                             \
} while (0)

# define ERR(Msg...) LOG(0, String::compose(Msg))
# define WARN(Msg...) LOG(1, String::compose(Msg))

# define LOG1(Msg...) LOG(2, String::compose(Msg))
# define LOG2(Msg...) LOG(3, String::compose(Msg))
# define LOG3(Msg...) LOG(4, String::compose(Msg))
# define LOG4(Msg...) LOG(5, String::compose(Msg))
# define LOG5(Msg...) LOG(6, String::compose(Msg))
# define LOG6(Msg...) LOG(7, String::compose(Msg))


#endif /* !LOG_H_ */

---