Log.h

Go to the documentation of this file.

#ifndef MUTILS_LOG_H
#define MUTILS_LOG_H

#include <cerrno>
#include <cstdio>
#include <cstring>
#include <string>

#define MU_MESSAGE(lev, src, msg, ...) do { \
    if ((lev) <= mutils::Log::level) { \
      bool db = (mutils::Log::level >= mutils::Log::DEBUG); \
      mutils::cxxfprintf(mutils::Log::stream, "%s: %s:%0*d: " msg "\n", \
                     mutils::Log::name(lev), (db ? (src) : ""), \
                     (db ? 1 : 4),  __LINE__, ## __VA_ARGS__); \
    } \
  } while (0)

#define MU_MESSAGE_IF(lev, cond, src, msg, ...) do { \
    if (cond) { MU_MESSAGE(lev, src, msg, ## __VA_ARGS__); } \
  } while (0)

#define MU_MESSAGE_RTN(lev, rtn, cond, src, msg, ...) do { \
    if (cond) { \
      MU_MESSAGE(lev, src, msg, ## __VA_ARGS__); \
      return (rtn); \
    } \
  } while (0)


#define MU_DEBUG(src, msg, ...) \
        MU_MESSAGE(mutils::Log::DEBUG, src, msg, ## __VA_ARGS__)

#define MU_DEBUG_IF(cond, src, msg, ...) \
        MU_MESSAGE_IF(mutils::Log::DEBUG, cond, src, msg, ## __VA_ARGS__)

#define MU_DEBUG_RTN(rtn, cond, src, msg, ...) \
        MU_MESSAGE_RTN(mutils::Log::DEBUG, rtn, cond, src, msg, ## __VA_ARGS__)


#define MU_INFO(src, msg, ...) \
        MU_MESSAGE(mutils::Log::INFO, src, msg, ## __VA_ARGS__)

#define MU_INFO_IF(cond, src, msg, ...) \
        MU_MESSAGE_IF(mutils::Log::INFO, cond, src, msg, ## __VA_ARGS__)

#define MU_INFO_RTN(rtn, cond, src, msg, ...) \
        MU_MESSAGE_RTN(mutils::Log::INFO, rtn, cond, src, msg, ## __VA_ARGS__)


#define MU_WARN(src, msg, ...) \
        MU_MESSAGE(mutils::Log::WARN, src, msg, ## __VA_ARGS__)

#define MU_WARN_IF(cond, src, msg, ...) \
        MU_MESSAGE_IF(mutils::Log::WARN, cond, src, msg, ## __VA_ARGS__)

#define MU_WARN_RTN(rtn, cond, src, msg, ...) \
        MU_MESSAGE_RTN(mutils::Log::WARN, rtn, cond, src, msg, ## __VA_ARGS__)


#define MU_ERROR(src, msg, ...) \
        MU_MESSAGE(mutils::Log::ERROR, src, msg, ## __VA_ARGS__)

#define MU_ERROR_IF(cond, src, msg, ...) \
        MU_MESSAGE_IF(mutils::Log::ERROR, cond, src, msg, ## __VA_ARGS__)

#define MU_ERROR_RTN(rtn, cond, src, msg, ...) \
        MU_MESSAGE_RTN(mutils::Log::ERROR, rtn, cond, src, msg, ## __VA_ARGS__)


#define MU_ERRNO_IF(cond, src, msg, ...) \
        MU_MESSAGE_IF(mutils::Log::ERROR, cond, src, msg ": %s", \
                      ## __VA_ARGS__, strerror(errno))

#define MU_ERRNO_RTN(rtn, cond, src, msg, ...) \
        MU_MESSAGE_RTN(mutils::Log::ERROR, rtn, cond, src, msg ": %s", \
                       ## __VA_ARGS__, strerror(errno))


namespace mutils {

inline const char *Cform(const std::string &s) { return s.c_str(); }

template<typename T>inline T *Cform(T *p) { return p; }

inline double Cform(double i) { return i; }

inline unsigned long Cform(unsigned long long i) { return i; }

inline unsigned long Cform(unsigned long i) { return i; }

inline unsigned long Cform(unsigned i) { return i; }

inline long Cform(long long i) { return i; }

inline long Cform(long i) { return i; }

inline long Cform(int i) { return i; }

inline int Cform(unsigned char i) { return i; }

inline int Cform(char i) { return i; }

template<typename... Args>
inline int cxxprintf(Args&&... args) { return printf(Cform(args)...); }

template<typename... Args>
inline int cxxfprintf(FILE *f, Args&&... args)
{ return fprintf(f, Cform(args)...); }

template<typename... Args>
inline int cxxsnprintf(char *buf, size_t len, Args&&... args)
{ return snprintf(buf, len, Cform(args)...); }

inline FILE *cxxfopen(const std::string &file, const char *mode)
{
  return (file == "-" ? (*mode == 'r' ? stdin : stdout) :
          file == "!" ? stderr : fopen(file.c_str(), mode));
}

inline int cxxfclose(FILE *fp)
{ return (fp == stdin || fp == stdout || fp == stderr ? 0 : fclose(fp)); }


struct Log {
  // Message logging levels.
  static constexpr int
    ERROR = 0,  
    WARN  = 1,  
    INFO  = 2,  
    DEBUG = 3;  

  static const char *name(int lev = mutils::Log::level) {
    if (lev <= ERROR) { return "ERROR"; }
    switch (lev) {
      case WARN:  return "WARN";
      case INFO:  return "INFO";
    }
    return "DEBUG";
  }

  static void setLevel(const std::string &str)
  {
    for (int l=ERROR; l<=DEBUG; l++) {
      if (str == name(l)) { level = l; }
    }
  }

  static int setStream(const std::string &fname, bool append = true)
  {
    FILE *f = cxxfopen(fname, append ? "ab" : "wb");
    if (f) {
      if (stream) { cxxfclose(stream); }
      file = fname;
      stream = f;
    }
    return (f ? 0 : -1);
  }

  template <typename... Args>
  static int message(int lev, Args&&... args)
  { return (lev <= level ? cxxfprintf(stream, args...) : 0); }

  template <typename... Args>
  static int error(Args&&... args)
  { return message(ERROR, args...); }

  template <typename... Args>
  static int warn(Args&&... args)
  { return message(WARN, args...); }

  template <typename... Args>
  static int info(Args&&... args)
  { return message(INFO, args...); }

  template <typename... Args>
  static int debug(Args&&... args)
  { return message(DEBUG, args...); }

  static int level;

  static FILE *stream;

  static std::string file;
};

}  // namespace mutils

#endif  // MUTILS_LOG_H