easylogging++.h

//
//  Easylogging++ v9.75
//  Single-header only, cross-platform logging library for C++ applications
//
//  Copyright (c) 2014 Majid Khan
//
//  This library is released under the MIT Licence.
//  http://www.easylogging.org/licence.php
//
//  support@easylogging.org
//  http://easylogging.org
//  https://github.com/easylogging/easyloggingpp
//
#ifndef EASYLOGGINGPP_H  // NOLINT
#define EASYLOGGINGPP_H
// Compilers and C++0x/C++11 Evaluation
#if defined(__GNUC__)
#   define _ELPP_COMPILER_GCC 1
#   define _ELPP_GCC_VERSION (__GNUC__ * 10000 \
                               + __GNUC_MINOR__ * 100 \
                               + __GNUC_PATCHLEVEL__)
#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
#      define _ELPP_CXX0X 1
#   elif(_ELPP_GCC_VERSION >= 40801)
#      define _ELPP_CXX11 1
#   endif  // defined(__GXX_EXPERIMENTAL_CXX0X__)
#endif  // defined(__GNUC__)
// Visual C++
#if defined(_MSC_VER)
#   define _ELPP_COMPILER_MSVC 1
#   define _ELPP_CRT_DBG_WARNINGS 1
#   if (_MSC_VER == 1600)
#      define _ELPP_CXX0X 1
#   elif(_MSC_VER >= 1700)
#      define _ELPP_CXX11 1
#   endif  // (_MSC_VER == 1600)
#endif  // defined(_MSC_VER)
// Clang++
#if defined(__clang__) && (__clang__ == 1)
#   define _ELPP_COMPILER_CLANG 1
#   define _ELPP_CLANG_VERSION (__clang_major__ * 10000 \
                                + __clang_minor__ * 100 \
                                + __clang_patchlevel__)
#   if (_ELPP_CLANG_VERSION >= 30300)
#      define _ELPP_CXX11 1
#   endif  // (_ELPP_CLANG_VERSION >= 30300)
#endif  // defined(__clang__) && (__clang__ == 1)
// MinGW
#if defined(__MINGW32__) || defined(__MINGW64__)
#   define _ELPP_MINGW 1
#endif  // defined(__MINGW32__) || defined(__MINGW64__)
// Cygwin
#if defined(__CYGWIN__) && (__CYGWIN__ == 1)
#   define _ELPP_CYGWIN 1
#endif  // defined(__CYGWIN__) && (__CYGWIN__ == 1)
// Intel C++
#if defined(__INTEL_COMPILER)
#   define _ELPP_COMPILER_INTEL 1
#endif
// Operating System Evaluation
// Windows
#if defined(_WIN32) || defined(_WIN64)
#   define _ELPP_OS_WINDOWS 1
#endif  // defined(_WIN32) || defined(_WIN64)
// Linux
#if (defined(__linux) || defined(__linux__))
#   define _ELPP_OS_LINUX 1
#endif  // (defined(__linux) || defined(__linux__))
// Mac
#if defined(__APPLE__)
#   define _ELPP_OS_MAC 1
#endif  // defined(__APPLE__)
// FreeBSD
#if defined(__FreeBSD__)
#   define _ELPP_OS_FREEBSD 1
#endif
// Unix
#if ((_ELPP_OS_LINUX || _ELPP_OS_MAC || _ELPP_OS_FREEBSD) && (!_ELPP_OS_WINDOWS))
#   define _ELPP_OS_UNIX 1
#endif  // ((_ELPP_OS_LINUX || _ELPP_OS_MAC || _ELPP_OS_FREEBSD) && (!_ELPP_OS_WINDOWS))
// Android
#if defined(__ANDROID__)
#   define _ELPP_OS_ANDROID 1
#endif  // defined(__ANDROID__)
// Evaluating Cygwin as *nix OS
#if !_ELPP_OS_UNIX && !_ELPP_OS_WINDOWS && _ELPP_CYGWIN
#   undef _ELPP_OS_UNIX
#   undef _ELPP_OS_LINUX
#   define _ELPP_OS_UNIX 1
#   define _ELPP_OS_LINUX 1
#endif //  !_ELPP_OS_UNIX && !_ELPP_OS_WINDOWS && _ELPP_CYGWIN
#if !defined(_ELPP_INTERNAL_DEBUGGING_OUT_INFO)
#   define _ELPP_INTERNAL_DEBUGGING_OUT_INFO std::cout
#endif // !defined(_ELPP_INTERNAL_DEBUGGING_OUT)
#if !defined(_ELPP_INTERNAL_DEBUGGING_OUT_ERROR)
#   define _ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr
#endif // !defined(_ELPP_INTERNAL_DEBUGGING_OUT)
#if !defined(_ELPP_INTERNAL_DEBUGGING_ENDL)
#   define _ELPP_INTERNAL_DEBUGGING_ENDL std::endl
#endif // !defined(_ELPP_INTERNAL_DEBUGGING_OUT)
#if !defined(_ELPP_INTERNAL_DEBUGGING_MSG)
#   define _ELPP_INTERNAL_DEBUGGING_MSG(msg) msg
#endif // !defined(_ELPP_INTERNAL_DEBUGGING_OUT)
// Internal Assertions and errors
#if !defined(_ELPP_DISABLE_ASSERT)
#   if (defined(_ELPP_DEBUG_ASSERT_FAILURE))
#      define ELPP_ASSERT(expr, msg) if (!(expr)) { \
          std::stringstream internalInfoStream; internalInfoStream << msg; \
          _ELPP_INTERNAL_DEBUGGING_OUT_ERROR \
              << "EASYLOGGING++ ASSERTION FAILED (LINE: " << __LINE__ << ") [" #expr << "] WITH MESSAGE \"" \
              << _ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" << _ELPP_INTERNAL_DEBUGGING_ENDL; base::utils::abort(1, \
                  "ELPP Assertion failure, please define _ELPP_DEBUG_ASSERT_FAILURE"); }
#   else
#      define ELPP_ASSERT(expr, msg) if (!(expr)) { \
          std::stringstream internalInfoStream; internalInfoStream << msg; \
          _ELPP_INTERNAL_DEBUGGING_OUT_ERROR\
             << "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \
             << __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << _ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \
             << _ELPP_INTERNAL_DEBUGGING_ENDL; }
#   endif  // (defined(_ELPP_DEBUG_ASSERT_FAILURE))
#else
#   define ELPP_ASSERT(x, y)
#endif  //(!defined(_ELPP_DISABLE_ASSERT)
#if _ELPP_COMPILER_MSVC
#   define _ELPP_INTERNAL_DEBUGGING_WRITE_PERROR \
       { char buff[256]; strerror_s(buff, 256, errno); \
       _ELPP_INTERNAL_DEBUGGING_OUT_ERROR << ": " << buff << " [" << errno << "]";} (void)0
#else
#   define _ELPP_INTERNAL_DEBUGGING_WRITE_PERROR \
        _ELPP_INTERNAL_DEBUGGING_OUT_ERROR << ": " << strerror(errno) << " [" << errno << "]"; (void)0
#endif  // _ELPP_COMPILER_MSVC
#if defined(_ELPP_DEBUG_ERRORS)
#   if !defined(ELPP_INTERNAL_ERROR)
#      define ELPP_INTERNAL_ERROR(msg, pe) { \
          std::stringstream internalInfoStream; internalInfoStream << "<ERROR> " << msg; \
          _ELPP_INTERNAL_DEBUGGING_OUT_ERROR \
          << "ERROR FROM EASYLOGGING++ (LINE: " << __LINE__ << ") " \
          << _ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << _ELPP_INTERNAL_DEBUGGING_ENDL; \
          if (pe) { _ELPP_INTERNAL_DEBUGGING_OUT_ERROR << "    "; _ELPP_INTERNAL_DEBUGGING_WRITE_PERROR; }} (void)0
#   endif
#else
#   undef ELPP_INTERNAL_INFO
#   define ELPP_INTERNAL_ERROR(msg, pe)
#endif  // defined(_ELPP_DEBUG_ERRORS)
#if (defined(_ELPP_DEBUG_INFO))
#   if !(defined(_ELPP_INTERNAL_INFO_LEVEL))
#      define _ELPP_INTERNAL_INFO_LEVEL 9
#   endif  // !(defined(_ELPP_INTERNAL_INFO_LEVEL))
#   if !defined(ELPP_INTERNAL_INFO)
#      define ELPP_INTERNAL_INFO(lvl, msg) { if (lvl <= _ELPP_INTERNAL_INFO_LEVEL) { \
          std::stringstream internalInfoStream; internalInfoStream << "<INFO> " << msg; \
          _ELPP_INTERNAL_DEBUGGING_OUT_INFO << _ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) \
             << _ELPP_INTERNAL_DEBUGGING_ENDL; }}
#   endif
#else
#   undef ELPP_INTERNAL_INFO
#   define ELPP_INTERNAL_INFO(lvl, msg)
#endif  // (defined(_ELPP_DEBUG_INFO))
#if defined(_ELPP_STACKTRACE_ON_CRASH)
#   if (_ELPP_COMPILER_GCC && !_ELPP_MINGW)
#      define _ELPP_STACKTRACE 1
#   else
#      if _ELPP_COMPILER_MSVC
#         pragma message("Stack trace not available for this compiler")
#      else
#         warning "Stack trace not available for this compiler";
#      endif  // _ELPP_COMPILER_MSVC
#   endif  // _ELPP_COMPILER_GCC
#endif  // (defined(_ELPP_STACKTRACE_ON_CRASH))
// Miscellaneous macros
#define _ELPP_UNUSED(x) (void)x
#if _ELPP_OS_UNIX
// Log file permissions for unix-based systems
#   define _ELPP_LOG_PERMS S_IRUSR | S_IWUSR | S_IXUSR | S_IWGRP | S_IRGRP | S_IXGRP | S_IWOTH | S_IXOTH
#endif  // _ELPP_OS_UNIX
#if defined(_ELPP_AS_DLL) && _ELPP_COMPILER_MSVC
#   if defined(_ELPP_EXPORT_SYMBOLS)
#      define _ELPP_EXPORT __declspec(dllexport)
#   else
#      define _ELPP_EXPORT __declspec(dllimport)
#   endif  // defined(_ELPP_EXPORT_SYMBOLS)
#else
#   define _ELPP_EXPORT
#endif  // defined(_ELPP_AS_DLL) && _ELPP_COMPILER_MSVC
// Some special functions that are VC++ specific
#undef STRTOK
#undef STRERROR
#undef STRCAT
#undef STRCPY
#if _ELPP_CRT_DBG_WARNINGS
#   define STRTOK(a, b, c) strtok_s(a, b, c)
#   define STRERROR(a, b, c) strerror_s(a, b, c)
#   define STRCAT(a, b, len) strcat_s(a, len, b)
#   define STRCPY(a, b, len) strcpy_s(a, len, b)
#else
#   define STRTOK(a, b, c) strtok(a, b)  // NOLINT
#   define STRERROR(a, b, c) strerror(c)
#   define STRCAT(a, b, len) strcat(a, b)  // NOLINT
#   define STRCPY(a, b, len) strcpy(a, b)  // NOLINT
#endif