Log.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_Log_hxx
#define __ccxx_Log_hxx

#include <commonc++/Common.h++>
#include <commonc++/ConsoleLogger.h++>
#include <commonc++/CriticalSection.h++>
#include <commonc++/FileLogger.h++>
#include <commonc++/Logger.h++>
#include <commonc++/String.h++>

#include <cstdarg>

namespace ccxx {

class COMMONCPP_API LogFunctor
{
 public:

  LogFunctor(const char *file, int line, LogLevel level = LogDebug,
             bool nodebug = false);
  ~LogFunctor();

  void operator()(const char *fmt, ...);
  void operator()(LogLevel level, const char *fmt, ...);

 private:

  const char *_file;
  int _line;
  LogLevel _level;
  bool _nodebug;
};
class COMMONCPP_API Log
{
  friend class LogFunctor;

 public:

  static void setFileLogFormat(const String& format);

  static void setConsoleLogFormat(const String& format);

  inline static void setUseConsoleLog(bool flag)
  { _useConsoleLog = flag; }

  static void setFileLogger(FileLogger* logger);

  inline static FileLogger* getFileLogger()
  { return(_fileLog); }

  static void setConsoleLogger(ConsoleLogger* logger);

  inline static ConsoleLogger* getConsoleLogger()
  { return(_consoleLog); }

  inline static void setUseFileLog(bool flag)
  { _useFileLog = flag; }

  static void setLogFile(const String& dir, const String& name);

  static void setLogFileMaxSize(size_t maxLogSize);

  static void setLogFileRotateCount(uint_t rotateCount);

  static void vlogFile(LogLevel level, const char* file, int line,
                       const char* message, va_list args);

  static void vlogConsole(LogLevel level, const char* file, int line,
                          const char* message, va_list args);

  static void log(LogLevel level, const char* file, int line,
                  const char* message, ...) ___PRINTF(4, 5);

  static bool assert_(const char* file, int line, const char* expr);

  /* temporary hackery */
  static void disableCleanup();

 private:

  static CriticalSection _lock;
  static ConsoleLogger* _consoleLog;
  static FileLogger* _fileLog;
  static bool _useConsoleLog;
  static bool _useFileLog;

  Log(); // not supported
  CCXX_COPY_DECLS(Log);
};

#define Log_assert(EXPR)                                                \
  (void)((EXPR)|| ccxx::Log::assert_(__FILE__, __LINE__, #EXPR))

#if (defined CCXX_OS_WINDOWS) && (defined _MSC_VER) && (_MSC_VER < 1400)

// no variadic macros; emulate with LogFunctor

#if (defined DEBUG) || (defined DEBUG_LOG_MESSAGES)

#define Log_debug                                       \
  ccxx::LogFunctor(__FILE__, __LINE__, ccxx::LogDebug)

#else // ! (DEBUG || DEBUG_LOG_MESSAGES)

#define Log_debug                                               \
  ccxx::LogFunctor(__FILE__, __LINE__, ccxx::LogDebug, true)

#endif // DEBUG || DEBUG_LOG_MESSAGES

#define Log_info                                        \
  ccxx::LogFunctor(__FILE__, __LINE__, ccxx::LogInfo)

#define Log_warning                                             \
  ccxx::LogFunctor(__FILE__, __LINE__, ccxx::LogWarning)

#define Log_error                                       \
  ccxx::LogFunctor(__FILE__, __LINE__, ccxx::LogError)

#elif (defined __GNUC__)

// gcc-style variadic macros (for compatibility with older versions of GCC)

#if (defined DEBUG) || (defined DEBUG_LOG_MESSAGES)

#define Log_debug(M, args...)                                           \
  ccxx::Log::log(ccxx::LogDebug, __FILE__, __LINE__, M, ## args)

#else // ! (DEBUG || DEBUG_LOG_MESSAGES)

#define Log_debug(M, args...)

#endif // DEBUG || DEBUG_LOG_MESSAGES

#define Log_info(M, args...)                                    \
  ccxx::Log::log(ccxx::LogInfo, __FILE__, __LINE__, M, ## args)

#define Log_warning(M, args...)                                         \
  ccxx::Log::log(ccxx::LogWarning, __FILE__, __LINE__, M, ## args)

#define Log_error(M, args...)                                           \
  ccxx::Log::log(ccxx::LogError, __FILE__, __LINE__,  M, ## args)

#else // assume ANSI compiler with support for C99 variadic macros

#if (defined DEBUG) || defined(DEBUG_LOG_MESSAGES)

#define Log_debug(M, ...)                                               \
  ccxx::Log::log(ccxx::LogDebug, __FILE__, __LINE__, M, __VA_ARGS__)

#else // ! (DEBUG || DEBUG_LOG_MESSAGES)

#define Log_debug(M, ...)

#endif // DEBUG || DEBUG_LOG_MESSAGES

#define Log_info(M, ...)                                                \
  ccxx::Log::log(ccxx::LogInfo, __FILE__, __LINE__, M, __VA_ARGS__)

#define Log_warning(M, ...)                                             \
  ccxx::Log::log(ccxx::LogWarning, __FILE__, __LINE__, M, __VA_ARGS__)

#define Log_error(M, ...)                                               \
  ccxx::Log::log(ccxx::LogError, __FILE__, __LINE__,  M, __VA_ARGS__)

#endif // variadic checks

} // namespace ccxx

#endif // __ccxx_Log_hxx