From f4898433dc74f88b6ed1ba2714f12decc8ad4f2c Mon Sep 17 00:00:00 2001 From: Merder Kim Date: Mon, 20 Jun 2016 15:09:20 +0300 Subject: [PATCH 1/5] ENH: grep utility added --- CMakeLists.txt | 6 +++ misc/grep.c | 144 +++++++++++++++++++++++++++++++++++++++++++++++++ src/csio.c | 2 +- 3 files changed, 151 insertions(+), 1 deletion(-) create mode 100644 misc/grep.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 4825c2c..590203f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -151,6 +151,12 @@ nx_add_library(csio ${CSIO_FORCE_SHARED_CRT} ${WITH_STATIC_LIBS} "${CSIO_SRC}") list(APPEND LIBRARIES csio) +######################################################################## +# grep + +add_executable(csio_grep misc/grep.c) +target_link_libraries(csio_grep ${LIBRARIES}) + ######################################################################## # docs diff --git a/misc/grep.c b/misc/grep.c new file mode 100644 index 0000000..11b59f1 --- /dev/null +++ b/misc/grep.c @@ -0,0 +1,144 @@ +#include +#include +#include +#include +#include +#include +#include + +char hex2char(unsigned char n) +{ + if(0 <= n && n <= 9) + return n + 48; + if(0xA <= n && n <= 0xF) + return n - 0xA + 'a'; + return '?'; +} + +int hex2int(unsigned char c) +{ + if ('0' <= c && c <= '9') + return c - '0'; + if ('a' <= c && c <= 'f') + return c - 'a' + 10; + if ('A' <= c && c <= 'F') + return c - 'A' + 10; + return -1; +} + +char* byte2str(char* begin, char* end, char* buf) +{ + int len = end - begin; + size_t i = 0; + for(; begin != end; ++begin) + { + buf[i] = hex2char((((unsigned char)*begin)/0x10)%0x10); + buf[i+1] = hex2char(((unsigned char)*begin)%0x10); + i += 2; + } + buf[i] = 0; + return buf; +} + +int +str2bytes(char* dst, const char* src, int srclen) +{ + if (srclen == 0 || src == NULL || dst == NULL) + return 0; + int pos = 0; + int rs = 0; + for(; pos < srclen; ++pos) + { + if(!isxdigit(src[pos])) + return rs; + int c = hex2int(src[pos]); + if (c == -1) + return rs; + dst[rs] = pos%2 ? dst[rs++] + c : c*0x10; + } + return rs; +} + +int main(int argc, char* argv[]) +{ + if (argc < 3) + { + printf("Usage: \n"); + return 0; + } + + size_t btlen = strlen(argv[2]); + if (btlen%2 != 0 || btlen == 0) + { + printf("Wrong pattern length."); + return 1; + } + char* target = (char*)malloc(btlen/2 + 1); + if (!target) + { + fprintf(stderr, "Error memory allocation.\n"); + return 1; + } + int targetsz = str2bytes(target, argv[2], btlen); + if (targetsz != (btlen%2 == 0 ? btlen/2 : btlen/2 + 1)) + { + fprintf(stderr, "Error converting second argument," + " processed %d bytes.\n", targetsz); + return 1; + } + + char realp[PATH_MAX]; + if (realpath(argv[1], realp) == NULL) + { + fprintf(stderr, "Error getting realpath of \"%s\". Message: %s\n", argv[1], strerror(errno)); + return 1; + } + CFILE* fin = cfopen(realp, "rb"); + if (!fin) + { + fprintf(stderr, "Error opening \"%s\". Message: %s\n", argv[1], strerror(errno)); + return 1; + } + char* buf = (char*)malloc(targetsz); + if (!buf) + { + fprintf(stderr, "Error memory allocation for readbuf. Size: %d\n", targetsz); + return 1; + } + int readrs = cfread(buf, 1, targetsz, fin); + if (readrs != targetsz) + { + if (read == 0) + fprintf(stderr, "Error reading file.\n"); + return 1; + } + if (memcmp(buf, target, targetsz) == 0) + { + printf("0\n"); + return 0; + } + while (!cfeof(fin)) + { + int c = cfgetc(fin); + if (c == EOF) + { + if (cferror(fin)) + { + fprintf(stderr, "Error reading file.\n"); + return 1; + } + return 0; + } + size_t i; + for (i = 0; i < targetsz - 1; ++i) // targetsz > 0 by logic + buf[i] = buf[i+1]; + buf[targetsz - 1] =c; + if (memcmp(buf, target, targetsz) == 0) + { + off_t off = cftello(fin); + printf("%s %lu\n", realp, (unsigned long)off); + } + } + return 0; +} + diff --git a/src/csio.c b/src/csio.c index 0596166..73c01ea 100644 --- a/src/csio.c +++ b/src/csio.c @@ -654,7 +654,7 @@ cfgetc(CFILE* stream) errno = EFAULT; return EOF; } - return stream->buf[stream->currpos++ - stream->bufoff]; + return (int)((unsigned char)stream->buf[stream->currpos++ - stream->bufoff]); } else { From 47ad608063e8c8bc9a1dea28d4ff3b070419921e Mon Sep 17 00:00:00 2001 From: hoxnox Date: Wed, 22 Jun 2016 08:25:15 +0300 Subject: [PATCH 2/5] ENH: conan build file and test_packaged added --- CMakeLists.txt | 139 ++++++++++++++++++++---------------- conanfile.py | 42 +++++++++++ test_package/CMakeLists.txt | 8 +++ test_package/conanfile.py | 25 +++++++ test_package/test.cpp | 35 +++++++++ 5 files changed, 188 insertions(+), 61 deletions(-) create mode 100644 conanfile.py create mode 100644 test_package/CMakeLists.txt create mode 100644 test_package/conanfile.py create mode 100644 test_package/test.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 2063a27..eb10f8e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -14,8 +14,10 @@ option(WITH_STATIC_LIBS "Build static libraries." ON) option(WITH_dzip "Build dzip compress utility" ON) option(WITH_SYSTEM_GLOG "Use system google-log" OFF) option(WITH_SYSTEM_ZMQ "Use system zeromq" OFF) +option(WITH_CONAN "Use conan as a dependency manager" OFF) option(CSIO_FORCE_SHARED_CRT "Use shared run-time lib even when csio is built as static lib." OFF) +option(WITH_GREP "Build naive grep utility" OFF) ######################################################################## # general @@ -47,72 +49,85 @@ include_directories("${PROJECT_SOURCE_DIR}/src" ######################################################################## # zlib -find_package(ZLIB REQUIRED) -include_directories(${ZLIB_INCLUDE_DIRS}) -list(APPEND LIBRARIES ${ZLIB_LIBRARIES}) +if (NOT WITH_CONAN) + find_package(ZLIB REQUIRED) + include_directories(${ZLIB_INCLUDE_DIRS}) + list(APPEND LIBRARIES ${ZLIB_LIBRARIES}) +endif() + +######################################################################## +# conan + +if (WITH_CONAN) + include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) + conan_basic_setup() + list(APPEND LIBRARIES ${CONAN_LIBS}) +endif() ######################################################################## # dzip if(WITH_dzip) - #################################################################### - # zmq - if (WITH_SYSTEM_ZMQ) - set(ZMQ_USE_STATIC_LIBS true) - find_package(ZMQ REQUIRED) - else() - include(ExternalProject) - set(ZMQ_ROOT "${CMAKE_CURRENT_BINARY_DIR}/zmq") - ExternalProject_Add(zmq - URL "${PROJECT_SOURCE_DIR}/third-party/zeromq-4.1.2.tar.gz" - URL_MD5 "159c0c56a895472f02668e692d122685" - PATCH_COMMAND ./autogen.sh - CONFIGURE_COMMAND ./configure --enable-static --disable-shared --without-libsodium --without-libgssapi_krb5 --without-documentation --prefix - INSTALL_DIR "${ZMQ_ROOT}" - BUILD_IN_SOURCE 1 - ) - set(ZMQ_INCLUDE_DIR ${ZMQ_ROOT}/include) - set(ZMQ_LIBRARIES ${ZMQ_ROOT}/lib/libzmq.a) - list(APPEND EXTERNAL_DEPS zmq) + if (NOT WITH_CONAN) + #################################################################### + # zmq + if (WITH_SYSTEM_ZMQ) + set(ZMQ_USE_STATIC_LIBS true) + find_package(ZMQ REQUIRED) + else() + include(ExternalProject) + set(ZMQ_ROOT "${CMAKE_CURRENT_BINARY_DIR}/zmq") + ExternalProject_Add(zmq + URL "${PROJECT_SOURCE_DIR}/third-party/zeromq-4.1.2.tar.gz" + URL_MD5 "159c0c56a895472f02668e692d122685" + PATCH_COMMAND ./autogen.sh + CONFIGURE_COMMAND ./configure --enable-static --disable-shared --without-libsodium --without-libgssapi_krb5 --without-documentation --prefix + INSTALL_DIR "${ZMQ_ROOT}" + BUILD_IN_SOURCE 1 + ) + set(ZMQ_INCLUDE_DIR ${ZMQ_ROOT}/include) + set(ZMQ_LIBRARIES ${ZMQ_ROOT}/lib/libzmq.a) + list(APPEND EXTERNAL_DEPS zmq) + endif() + + #################################################################### + # glog + if (WITH_SYSTEM_GLOG) + set(Glog_USE_STATIC_LIBS true) + find_package(Glog REQUIRED) + else() + include(ExternalProject) + set(LIBUNWIND_ROOT "${CMAKE_CURRENT_BINARY_DIR}/libunwind") + ExternalProject_Add(libunwind + URL "${PROJECT_SOURCE_DIR}/third-party/libunwind-1.1.tar.gz" + URL_MD5 "fb4ea2f6fbbe45bf032cd36e586883ce" + CONFIGURE_COMMAND ./configure --disable-minidebuginfo --enable-static --disable-shared --prefix + INSTALL_DIR "${LIBUNWIND_ROOT}" + BUILD_IN_SOURCE 1 + ) + set(LIBUNWIND_INCLUDE_DIR ${LIBUNWIND_ROOT}/include) + set(LIBUNWIND_LIBRARIES ${LIBUNWIND_ROOT}/lib/libunwind.a) + + set(Glog_ROOT "${CMAKE_CURRENT_BINARY_DIR}/glog") + ExternalProject_Add(glog + URL "${PROJECT_SOURCE_DIR}/third-party/glog-0.3.3.tar.gz" + URL_MD5 "a6fd2c22f8996846e34c763422717c18" + CONFIGURE_COMMAND ./configure --enable-static --disable-shared --prefix + INSTALL_DIR "${Glog_ROOT}" + BUILD_IN_SOURCE 1 + ) + set(Glog_INCLUDE_DIR ${Glog_ROOT}/include) + set(Glog_LIBRARIES ${Glog_ROOT}/lib/libglog.a ${LIBUNWIND_LIBRARIES}) + add_dependencies(glog libunwind) + message(STATUS "Found external dependency GLOG: " ${Glog_INCLUDE_DIR}) + list(APPEND EXTERNAL_DEPS glog) + endif() + include_directories(${ZMQ_INCLUDE_DIR}) + include_directories(${Glog_INCLUDE_DIR}) + list(APPEND LIBRARIES ${Glog_LIBRARIES} ${ZMQ_LIBRARIES} pthread rt) endif() - #################################################################### - # glog - if (WITH_SYSTEM_GLOG) - set(Glog_USE_STATIC_LIBS true) - find_package(Glog REQUIRED) - else() - include(ExternalProject) - set(LIBUNWIND_ROOT "${CMAKE_CURRENT_BINARY_DIR}/libunwind") - ExternalProject_Add(libunwind - URL "${PROJECT_SOURCE_DIR}/third-party/libunwind-1.1.tar.gz" - URL_MD5 "fb4ea2f6fbbe45bf032cd36e586883ce" - CONFIGURE_COMMAND ./configure --disable-minidebuginfo --enable-static --disable-shared --prefix - INSTALL_DIR "${LIBUNWIND_ROOT}" - BUILD_IN_SOURCE 1 - ) - set(LIBUNWIND_INCLUDE_DIR ${LIBUNWIND_ROOT}/include) - set(LIBUNWIND_LIBRARIES ${LIBUNWIND_ROOT}/lib/libunwind.a) - - set(Glog_ROOT "${CMAKE_CURRENT_BINARY_DIR}/glog") - ExternalProject_Add(glog - URL "${PROJECT_SOURCE_DIR}/third-party/glog-0.3.3.tar.gz" - URL_MD5 "a6fd2c22f8996846e34c763422717c18" - CONFIGURE_COMMAND ./configure --enable-static --disable-shared --prefix - INSTALL_DIR "${Glog_ROOT}" - BUILD_IN_SOURCE 1 - ) - set(Glog_INCLUDE_DIR ${Glog_ROOT}/include) - set(Glog_LIBRARIES ${Glog_ROOT}/lib/libglog.a ${LIBUNWIND_LIBRARIES}) - add_dependencies(glog libunwind) - message(STATUS "Found external dependency GLOG: " ${Glog_INCLUDE_DIR}) - list(APPEND EXTERNAL_DEPS glog) - endif() - - include_directories(${ZMQ_INCLUDE_DIR}) - include_directories(${Glog_INCLUDE_DIR}) - list(APPEND LIBRARIES ${Glog_LIBRARIES} ${ZMQ_LIBRARIES} pthread rt) find_package(Threads REQUIRED) if (NOT CMAKE_USE_PTHREADS_INIT) message(FATAL_ERROR "dzip utility needs pthreads") @@ -133,7 +148,7 @@ if(WITH_dzip) ) set(DZIP_SRC ./src/dzip.cpp) add_executable(dzip ${DZIP_SRC}) - if (EXTERNAL_DEPS) + if (EXTERNAL_DEPS AND NOT WITH_CONAN) add_dependencies(dzip_internal ${EXTERNAL_DEPS}) endif() target_link_libraries(dzip dzip_internal ${LIBRARIES}) @@ -154,8 +169,10 @@ list(APPEND LIBRARIES csio) ######################################################################## # grep -add_executable(csio_grep misc/grep.c) -target_link_libraries(csio_grep ${LIBRARIES}) +if (WITH_GREP) + add_executable(csio_grep misc/grep.c) + target_link_libraries(csio_grep ${LIBRARIES}) +endif() ######################################################################## # docs diff --git a/conanfile.py b/conanfile.py new file mode 100644 index 0000000..d06f399 --- /dev/null +++ b/conanfile.py @@ -0,0 +1,42 @@ +from conans import ConanFile, CMake + +class SnappyStreamConan(ConanFile): + name = "csio" + version = "0.1.2" + requires = "" + settings = "os", "compiler", "build_type", "arch" + options = {"shared": [True, False], "dzip": [True, False]} + default_options = "shared=False", "dzip=False", "glog:shared=False", "zlib:shared=False", "libzmq:shared=False" + generators = "cmake" + exports = "*" + + def requirements(self): + if self.options.dzip: + self.requires("zlib/1.2.8@lasote/stable") + self.requires("libzmq/4.1.5@memsharded/stable") + self.requires("glog/0.3.4@dwerner/testing") + else: + self.requires("zlib/1.2.8@lasote/stable") + + def build(self): + cmake = CMake(self.settings) + other_opts = "" + if self.options.dzip: + other_opts = "-DWITH_dzip=1" + else: + other_opts = "-DWITH_dzip=0" + self.run('cmake %s -DWITH_CONAN=1 -DCMAKE_INSTALL_PREFIX=./distr %s %s' % + (self.conanfile_directory, cmake.command_line, other_opts)) + self.run("cmake --build . %s" % cmake.build_config) + self.run("make install") + + + def package(self): + if self.options.dzip: + self.copy("dzip", dst="bin", src="distr/bin") + self.copy("*.h", dst="include", src="distr/include") + self.copy("*.a", dst="lib", src="distr/lib") + + def package_info(self): + self.cpp_info.libs = ["csio"] + diff --git a/test_package/CMakeLists.txt b/test_package/CMakeLists.txt new file mode 100644 index 0000000..d834f17 --- /dev/null +++ b/test_package/CMakeLists.txt @@ -0,0 +1,8 @@ +PROJECT(SnappyStreamTest) +cmake_minimum_required(VERSION 2.8.12) + +include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) +conan_basic_setup() + +ADD_EXECUTABLE(test test.cpp) +TARGET_LINK_LIBRARIES(test ${CONAN_LIBS}) diff --git a/test_package/conanfile.py b/test_package/conanfile.py new file mode 100644 index 0000000..7a48ff9 --- /dev/null +++ b/test_package/conanfile.py @@ -0,0 +1,25 @@ +from conans import ConanFile, CMake +import os + +channel = os.getenv("CONAN_CHANNEL", "testing") +username = os.getenv("CONAN_USERNAME", "hoxnox") + +class SnappyStreamTestConan(ConanFile): + settings = "os", "compiler", "build_type", "arch" + requires = "csio/0.1.2@%s/%s" % (username, channel) + default_options = "csio:dzip=True" + generators = "cmake" + + def build(self): + cmake = CMake(self.settings) + self.run('cmake "%s" %s' % (self.conanfile_directory, cmake.command_line)) + self.run("cmake --build . %s" % cmake.build_config) + + def imports(self): + self.copy("*.dll", "bin", "bin") + self.copy("dzip", "bin", "bin") + self.copy("*.dylib", "bin", "lib") + + def test(self): + os.chdir("bin") + self.run(".%stest" % os.sep) diff --git a/test_package/test.cpp b/test_package/test.cpp new file mode 100644 index 0000000..67983aa --- /dev/null +++ b/test_package/test.cpp @@ -0,0 +1,35 @@ +#include +#include +#include +#include +#include + +std::string +prepare_sample_file() +{ + const char sample[] = { + 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x20, + 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21 + }; + std::string fname = std::tmpnam(NULL); + std::basic_fstream ofile(fname.c_str(), std::ios::binary | std::ios::out); + if (!ofile.is_open()) + return std::string(); + ofile.write(sample, sizeof(sample)); + return fname; +} + +int main(int argc, char * argv[]) +{ + std::string fname = prepare_sample_file(); + if (fname.empty()) + return -1; + CFILE* cfile = cfopen(fname.c_str(), "r"); + char buf[20]; + if (cfread(buf, 1, 13, cfile) != 13) + return -1; + if (std::string(buf) != "Hello, world!") + return -1; + return 0; +} + From 4ab7a84afbe720bf174ab9684c2b4577b173455f Mon Sep 17 00:00:00 2001 From: hoxnox Date: Wed, 22 Jun 2016 08:51:28 +0300 Subject: [PATCH 3/5] ENH: glog->easylogging to simplify dependencies --- CMakeLists.txt | 40 +- src/CompressManager.cpp | 16 +- src/dzip.cpp | 2 + src/easylogging++.h | 6663 +++++++++++++++++++++++++++++++++ src/logging.hpp | 25 +- third-party/glog-0.3.3.tar.gz | Bin 509676 -> 0 bytes 6 files changed, 6691 insertions(+), 55 deletions(-) create mode 100644 src/easylogging++.h delete mode 100644 third-party/glog-0.3.3.tar.gz diff --git a/CMakeLists.txt b/CMakeLists.txt index 2063a27..f3bbdb2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,7 +12,6 @@ option(WITH_DOCS "Generate docs." OFF) option(WITH_SHARED_LIBS "Build shared libraries." OFF) option(WITH_STATIC_LIBS "Build static libraries." ON) option(WITH_dzip "Build dzip compress utility" ON) -option(WITH_SYSTEM_GLOG "Use system google-log" OFF) option(WITH_SYSTEM_ZMQ "Use system zeromq" OFF) option(CSIO_FORCE_SHARED_CRT "Use shared run-time lib even when csio is built as static lib." OFF) @@ -76,47 +75,14 @@ if(WITH_dzip) set(ZMQ_LIBRARIES ${ZMQ_ROOT}/lib/libzmq.a) list(APPEND EXTERNAL_DEPS zmq) endif() - - #################################################################### - # glog - if (WITH_SYSTEM_GLOG) - set(Glog_USE_STATIC_LIBS true) - find_package(Glog REQUIRED) - else() - include(ExternalProject) - set(LIBUNWIND_ROOT "${CMAKE_CURRENT_BINARY_DIR}/libunwind") - ExternalProject_Add(libunwind - URL "${PROJECT_SOURCE_DIR}/third-party/libunwind-1.1.tar.gz" - URL_MD5 "fb4ea2f6fbbe45bf032cd36e586883ce" - CONFIGURE_COMMAND ./configure --disable-minidebuginfo --enable-static --disable-shared --prefix - INSTALL_DIR "${LIBUNWIND_ROOT}" - BUILD_IN_SOURCE 1 - ) - set(LIBUNWIND_INCLUDE_DIR ${LIBUNWIND_ROOT}/include) - set(LIBUNWIND_LIBRARIES ${LIBUNWIND_ROOT}/lib/libunwind.a) - - set(Glog_ROOT "${CMAKE_CURRENT_BINARY_DIR}/glog") - ExternalProject_Add(glog - URL "${PROJECT_SOURCE_DIR}/third-party/glog-0.3.3.tar.gz" - URL_MD5 "a6fd2c22f8996846e34c763422717c18" - CONFIGURE_COMMAND ./configure --enable-static --disable-shared --prefix - INSTALL_DIR "${Glog_ROOT}" - BUILD_IN_SOURCE 1 - ) - set(Glog_INCLUDE_DIR ${Glog_ROOT}/include) - set(Glog_LIBRARIES ${Glog_ROOT}/lib/libglog.a ${LIBUNWIND_LIBRARIES}) - add_dependencies(glog libunwind) - message(STATUS "Found external dependency GLOG: " ${Glog_INCLUDE_DIR}) - list(APPEND EXTERNAL_DEPS glog) - endif() - include_directories(${ZMQ_INCLUDE_DIR}) - include_directories(${Glog_INCLUDE_DIR}) - list(APPEND LIBRARIES ${Glog_LIBRARIES} ${ZMQ_LIBRARIES} pthread rt) + find_package(Threads REQUIRED) if (NOT CMAKE_USE_PTHREADS_INIT) message(FATAL_ERROR "dzip utility needs pthreads") endif() + list(APPEND LIBRARIES ${ZMQ_LIBRARIES} pthread rt) + add_library(dzip_internal STATIC ./src/ProcessManagerBase.hpp ./src/ProcessManagerBase.cpp diff --git a/src/CompressManager.cpp b/src/CompressManager.cpp index 74a9c79..3bf734d 100644 --- a/src/CompressManager.cpp +++ b/src/CompressManager.cpp @@ -1,7 +1,6 @@ /**@author Merder Kim * @date 20140404 19:40:10 */ -#include #include #include #include @@ -13,6 +12,7 @@ #include "CompressManager.hpp" #include "Utils.hpp" #include "Messages.hpp" +#include "logging.hpp" namespace csio { @@ -31,7 +31,7 @@ CompressManager::CompressManager(const Config& cfg) , msg_pushed_(0) , compressors_count_(0) { - LOG_IF(ERROR, !zmq_ctx_) + LOG_IF(!zmq_ctx_, ERROR) << _("CompressManager: error creating communication context.") << _(" Message: ") << zmq_strerror(errno); }; @@ -274,9 +274,9 @@ CompressManager::processWriterIncoming() { Message msg; msg.Fetch(sock_writer_); - LOG_IF(ERROR, msg == MSG_ERROR) + LOG_IF(msg == MSG_ERROR, ERROR) << _("CompressManager: received MSG_ERROR from the writer."); - LOG_IF(ERROR, msg.Type() == Message::TYPE_UNKNOWN) + LOG_IF(msg.Type() == Message::TYPE_UNKNOWN, ERROR) << _("CompressManager: error fetching message from the writer") << _(" Message: ") << zmq_strerror(errno); return POLL_BREAK; @@ -348,9 +348,9 @@ CompressManager::createSocks() "inproc://writer", ZMQ_PAIR, MSG_QUEUE_HWM); - VLOG_IF(2, sock_outbox_ == NULL) << _("Error with jobs socket."); - VLOG_IF(2, sock_inbox_ == NULL) << _("Error with feedback socket."); - VLOG_IF(2, sock_writer_ == NULL) << _("Error with writer socket."); + VLOG_IF(sock_outbox_ == NULL, 2) << _("Error with jobs socket."); + VLOG_IF(sock_inbox_ == NULL, 2) << _("Error with feedback socket."); + VLOG_IF(sock_writer_ == NULL, 2) << _("Error with writer socket."); if (!sock_outbox_ || !sock_inbox_ || !sock_writer_) return false; return true; @@ -436,7 +436,7 @@ CompressManager::waitChildrenReady(const size_t timeout_ms) while(deadline > std::chrono::system_clock::now()) { int rs = zmq_poll(poll_items, 2, TICK); - VLOG_IF(2, rs == -1) + VLOG_IF(rs == -1, 2) << _("CompressManager: error threads initialization.") << _(" Message: ") << zmq_strerror(errno); diff --git a/src/dzip.cpp b/src/dzip.cpp index 8e5e716..3ea2439 100644 --- a/src/dzip.cpp +++ b/src/dzip.cpp @@ -9,6 +9,8 @@ using namespace csio; +INIT_LOGGING + int main(int argc, char * argv[]) { diff --git a/src/easylogging++.h b/src/easylogging++.h new file mode 100644 index 0000000..f9a67fe --- /dev/null +++ b/src/easylogging++.h @@ -0,0 +1,6663 @@ +// +// Easylogging++ v9.80 +// Single-header only, cross-platform logging library for C++ applications +// +// Copyright (c) 2015 muflihun.com +// +// This library is released under the MIT Licence. +// http://easylogging.muflihun.com/licence.php +// +// easylogging@muflihun.com +// +// https://github.com/easylogging/easyloggingpp +// http://easylogging.muflihun.com +// http://muflihun.com +// +#ifndef EASYLOGGINGPP_H +#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 +// Solaris +#if defined(__sun) +# define ELPP_OS_SOLARIS 1 +#endif +// Unix +#if ((ELPP_OS_LINUX || ELPP_OS_MAC || ELPP_OS_FREEBSD || ELPP_OS_SOLARIS) && (!ELPP_OS_WINDOWS)) +# define ELPP_OS_UNIX 1 +#endif // ((ELPP_OS_LINUX || ELPP_OS_MAC || ELPP_OS_FREEBSD || ELPP_OS_SOLARIS) && (!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 << " " << 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 << " " << 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) +# define STRERROR(a, b, c) strerror(c) +# define STRCAT(a, b, len) strcat(a, b) +# define STRCPY(a, b, len) strcpy(a, b) +#endif +// Compiler specific support evaluations +#if (!ELPP_MINGW && !ELPP_COMPILER_CLANG) || defined(ELPP_FORCE_USE_STD_THREAD) +# define ELPP_USE_STD_THREADING 1 +#endif // (!ELPP_MINGW && !ELPP_COMPILER_CLANG) || defined(ELPP_FORCE_USE_STD_THREAD) +#undef ELPP_FINAL +#if ELPP_COMPILER_INTEL || (ELPP_GCC_VERSION < 40702) +# define ELPP_FINAL +#else +# define ELPP_FINAL final +#endif // ELPP_COMPILER_INTEL || (ELPP_GCC_VERSION < 40702) +#if defined(ELPP_EXPERIMENTAL_ASYNC) +# define ELPP_ASYNC_LOGGING 1 +#else +# define ELPP_ASYNC_LOGGING 0 +#endif // defined(ELPP_EXPERIMENTAL_ASYNC) +#if defined(ELPP_THREAD_SAFE) || ELPP_ASYNC_LOGGING +# define ELPP_THREADING_ENABLED 1 +#endif // defined(ELPP_THREAD_SAFE) || ELPP_ASYNC_LOGGING +// Function macro ELPP_FUNC +#undef ELPP_FUNC +#if ELPP_COMPILER_MSVC // Visual C++ +# define ELPP_FUNC __FUNCSIG__ +#elif ELPP_COMPILER_GCC // GCC +# define ELPP_FUNC __PRETTY_FUNCTION__ +#elif ELPP_COMPILER_INTEL // Intel C++ +# define ELPP_FUNC __PRETTY_FUNCTION__ +#elif ELPP_COMPILER_CLANG // Clang++ +# define ELPP_FUNC __PRETTY_FUNCTION__ +#else +# if defined(__func__) +# define ELPP_FUNC __func__ +# else +# define ELPP_FUNC "" +# endif // defined(__func__) +#endif // defined(_MSC_VER) +#undef ELPP_VARIADIC_TEMPLATES_SUPPORTED +// Keep following line commented until features are fixed +#if ELPP_COMPILER_GCC || ELPP_COMPILER_CLANG || ELPP_COMPILER_INTEL || (ELPP_COMPILER_MSVC && _MSC_VER >= 1800) +# define ELPP_VARIADIC_TEMPLATES_SUPPORTED 1 +#endif // ELPP_COMPILER_GCC || ELPP_COMPILER_CLANG || ELPP_COMPILER_INTEL || (ELPP_COMPILER_MSVC && _MSC_VER >= 1800) +// Logging Enable/Disable macros +#if (!defined(ELPP_DISABLE_LOGS)) +# define ELPP_LOGGING_ENABLED 1 +#endif // (!defined(ELPP_DISABLE_LOGS)) +#if (!defined(ELPP_DISABLE_DEBUG_LOGS) && (ELPP_LOGGING_ENABLED) && ((defined(_DEBUG)) || (!defined(NDEBUG)))) +# define ELPP_DEBUG_LOG 1 +#else +# define ELPP_DEBUG_LOG 0 +#endif // (!defined(ELPP_DISABLE_DEBUG_LOGS) && (ELPP_LOGGING_ENABLED) && ((defined(_DEBUG)) || (!defined(NDEBUG)))) +#if (!defined(ELPP_DISABLE_INFO_LOGS) && (ELPP_LOGGING_ENABLED)) +# define ELPP_INFO_LOG 1 +#else +# define ELPP_INFO_LOG 0 +#endif // (!defined(ELPP_DISABLE_INFO_LOGS) && (ELPP_LOGGING_ENABLED)) +#if (!defined(ELPP_DISABLE_WARNING_LOGS) && (ELPP_LOGGING_ENABLED)) +# define ELPP_WARNING_LOG 1 +#else +# define ELPP_WARNING_LOG 0 +#endif // (!defined(ELPP_DISABLE_WARNING_LOGS) && (ELPP_LOGGING_ENABLED)) +#if (!defined(ELPP_DISABLE_ERROR_LOGS) && (ELPP_LOGGING_ENABLED)) +# define ELPP_ERROR_LOG 1 +#else +# define ELPP_ERROR_LOG 0 +#endif // (!defined(ELPP_DISABLE_ERROR_LOGS) && (ELPP_LOGGING_ENABLED)) +#if (!defined(ELPP_DISABLE_FATAL_LOGS) && (ELPP_LOGGING_ENABLED)) +# define ELPP_FATAL_LOG 1 +#else +# define ELPP_FATAL_LOG 0 +#endif // (!defined(ELPP_DISABLE_FATAL_LOGS) && (ELPP_LOGGING_ENABLED)) +#if (!defined(ELPP_DISABLE_TRACE_LOGS) && (ELPP_LOGGING_ENABLED)) +# define ELPP_TRACE_LOG 1 +#else +# define ELPP_TRACE_LOG 0 +#endif // (!defined(ELPP_DISABLE_TRACE_LOGS) && (ELPP_LOGGING_ENABLED)) +#if (!defined(ELPP_DISABLE_VERBOSE_LOGS) && (ELPP_LOGGING_ENABLED)) +# define ELPP_VERBOSE_LOG 1 +#else +# define ELPP_VERBOSE_LOG 0 +#endif // (!defined(ELPP_DISABLE_VERBOSE_LOGS) && (ELPP_LOGGING_ENABLED)) +#if (!(ELPP_CXX0X || ELPP_CXX11)) +# error "Easylogging++ 9.0+ is only compatible with C++0x (or higher) compliant compiler" +#endif // (!(ELPP_CXX0X || ELPP_CXX11)) +// Headers +#if defined(ELPP_SYSLOG) +# include +#endif // defined(ELPP_SYSLOG) +#include +#include +#include +#include +#include +#include +#include +#include +#if defined(ELPP_UNICODE) +# include +# if ELPP_OS_WINDOWS +# include +# endif // ELPP_OS_WINDOWS +#endif // defined(ELPP_UNICODE) +#if ELPP_STACKTRACE +# include +# include +#endif // ELPP_STACKTRACE +#if ELPP_OS_ANDROID +# include +#endif // ELPP_OS_ANDROID +#if ELPP_OS_UNIX +# include +# include +#elif ELPP_OS_WINDOWS +# include +# include +# if defined(WIN32_LEAN_AND_MEAN) +# if defined(ELPP_WINSOCK2) +# include +# else +# include +# endif // defined(ELPP_WINSOCK2) +# endif // defined(WIN32_LEAN_AND_MEAN) +#endif // ELPP_OS_UNIX +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if ELPP_THREADING_ENABLED +# if ELPP_USE_STD_THREADING +# include +# include +# else +# if ELPP_OS_UNIX +# include +# endif // ELPP_OS_UNIX +# endif // ELPP_USE_STD_THREADING +#endif // ELPP_THREADING_ENABLED +#if ELPP_ASYNC_LOGGING +# include +# include +# include +#endif // ELPP_ASYNC_LOGGING +#if defined(ELPP_STL_LOGGING) +// For logging STL based templates +# include +# include +# include +# include +# include +# include +# if defined(ELPP_LOG_STD_ARRAY) +# include +# endif // defined(ELPP_LOG_STD_ARRAY) +# if defined(ELPP_LOG_UNORDERED_MAP) +# include +# endif // defined(ELPP_LOG_UNORDERED_MAP) +# if defined(ELPP_LOG_UNORDERED_SET) +# include +# endif // defined(ELPP_UNORDERED_SET) +#endif // defined(ELPP_STL_LOGGING) +#if defined(ELPP_QT_LOGGING) +// For logging Qt based classes & templates +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +#endif // defined(ELPP_QT_LOGGING) +#if defined(ELPP_BOOST_LOGGING) +// For logging boost based classes & templates +# include +# include +# include +# include +# include +# include +# include +# include +#endif // defined(ELPP_BOOST_LOGGING) +#if defined(ELPP_WXWIDGETS_LOGGING) +// For logging wxWidgets based classes & templates +# include +#endif // defined(ELPP_WXWIDGETS_LOGGING) +// Forward declarations +namespace el { +class Logger; +class LogMessage; +class PerformanceTrackingData; +class Loggers; +class Helpers; +template class Callback; +class LogDispatchCallback; +class PerformanceTrackingCallback; +class LogDispatchData; +namespace base { +class Storage; +class RegisteredLoggers; +class PerformanceTracker; +class MessageBuilder; +class Writer; +class PErrorWriter; +class LogDispatcher; +class DefaultLogBuilder; +class DefaultLogDispatchCallback; +#if ELPP_ASYNC_LOGGING +class AsyncLogDispatchCallback; +class AsyncDispatchWorker; +#endif // ELPP_ASYNC_LOGGING +class DefaultPerformanceTrackingCallback; +} // namespace base +} // namespace el +/// @brief Easylogging++ entry namespace +namespace el { +/// @brief Namespace containing base/internal functionality used by Easylogging++ +namespace base { +/// @brief Data types used by Easylogging++ +namespace type { +#undef ELPP_LITERAL +#undef ELPP_STRLEN +#undef ELPP_COUT +#if defined(ELPP_UNICODE) +# define ELPP_LITERAL(txt) L##txt +# define ELPP_STRLEN wcslen +# if defined ELPP_CUSTOM_COUT +# define ELPP_COUT ELPP_CUSTOM_COUT +# else +# define ELPP_COUT std::wcout +# endif // defined ELPP_CUSTOM_COUT +typedef wchar_t char_t; +typedef std::wstring string_t; +typedef std::wstringstream stringstream_t; +typedef std::wfstream fstream_t; +typedef std::wostream ostream_t; +#else +# define ELPP_LITERAL(txt) txt +# define ELPP_STRLEN strlen +# if defined ELPP_CUSTOM_COUT +# define ELPP_COUT ELPP_CUSTOM_COUT +# else +# define ELPP_COUT std::cout +# endif // defined ELPP_CUSTOM_COUT +typedef char char_t; +typedef std::string string_t; +typedef std::stringstream stringstream_t; +typedef std::fstream fstream_t; +typedef std::ostream ostream_t; +#endif // defined(ELPP_UNICODE) +#if defined(ELPP_CUSTOM_COUT_LINE) +# define ELPP_COUT_LINE(logLine) ELPP_CUSTOM_COUT_LINE(logLine) +#else +# define ELPP_COUT_LINE(logLine) logLine << std::flush +#endif // defined(ELPP_CUSTOM_COUT_LINE) +typedef unsigned short EnumType; +typedef std::shared_ptr StoragePointer; +typedef int VerboseLevel; +typedef std::shared_ptr LogDispatchCallbackPtr; +typedef std::shared_ptr PerformanceTrackingCallbackPtr; +} // namespace type +/// @brief Internal helper class that prevent copy constructor for class +/// +/// @detail When using this class simply inherit it privately +class NoCopy { +protected: + NoCopy(void) {} +private: + NoCopy(const NoCopy&); + NoCopy& operator=(const NoCopy&); +}; +/// @brief Internal helper class that makes all default constructors private. +/// +/// @detail This prevents initializing class making it static unless an explicit constructor is declared. +/// When using this class simply inherit it privately +class StaticClass { +private: + StaticClass(void); + StaticClass(const StaticClass&); + StaticClass& operator=(const StaticClass&); +}; +} // namespace base +/// @brief Represents enumeration for severity level used to determine level of logging +/// +/// @detail With Easylogging++, developers may disable or enable any level regardless of +/// what the severity is. Or they can choose to log using hierarchical logging flag +enum class Level : base::type::EnumType { + /// @brief Generic level that represents all the levels. Useful when setting global configuration for all levels + Global = 1, + /// @brief Information that can be useful to back-trace certain events - mostly useful than debug logs. + Trace = 2, + /// @brief Informational events most useful for developers to debug application + Debug = 4, + /// @brief Severe error information that will presumably abort application + Fatal = 8, + /// @brief Information representing errors in application but application will keep running + Error = 16, + /// @brief Useful when application has potentially harmful situtaions + Warning = 32, + /// @brief Information that can be highly useful and vary with verbose logging level. + Verbose = 64, + /// @brief Mainly useful to represent current progress of application + Info = 128, + /// @brief Represents unknown level + Unknown = 1010 +}; +/// @brief Static class that contains helper functions for el::Level +class LevelHelper : base::StaticClass { +public: + /// @brief Represents minimum valid level. Useful when iterating through enum. + static const base::type::EnumType kMinValid = static_cast(Level::Trace); + /// @brief Represents maximum valid level. This is used internally and you should not need it. + static const base::type::EnumType kMaxValid = static_cast(Level::Info); + /// @brief Casts level to int, useful for iterating through enum. + static base::type::EnumType castToInt(Level level) { + return static_cast(level); + } + /// @brief Casts int(ushort) to level, useful for iterating through enum. + static Level castFromInt(base::type::EnumType l) { + return static_cast(l); + } + /// @brief Converts level to associated const char* + /// @return Upper case string based level. + static const char* convertToString(Level level) { + // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet. + if (level == Level::Global) return "GLOBAL"; + if (level == Level::Debug) return "DEBUG"; + if (level == Level::Info) return "INFO"; + if (level == Level::Warning) return "WARNING"; + if (level == Level::Error) return "ERROR"; + if (level == Level::Fatal) return "FATAL"; + if (level == Level::Verbose) return "VERBOSE"; + if (level == Level::Trace) return "TRACE"; + return "UNKNOWN"; + } + /// @brief Converts from levelStr to Level + /// @param levelStr Upper case string based level. + /// Lower case is also valid but providing upper case is recommended. + static Level convertFromString(const char* levelStr) { + if ((strcmp(levelStr, "GLOBAL") == 0) || (strcmp(levelStr, "global") == 0)) + return Level::Global; + if ((strcmp(levelStr, "DEBUG") == 0) || (strcmp(levelStr, "debug") == 0)) + return Level::Debug; + if ((strcmp(levelStr, "INFO") == 0) || (strcmp(levelStr, "info") == 0)) + return Level::Info; + if ((strcmp(levelStr, "WARNING") == 0) || (strcmp(levelStr, "warning") == 0)) + return Level::Warning; + if ((strcmp(levelStr, "ERROR") == 0) || (strcmp(levelStr, "error") == 0)) + return Level::Error; + if ((strcmp(levelStr, "FATAL") == 0) || (strcmp(levelStr, "fatal") == 0)) + return Level::Fatal; + if ((strcmp(levelStr, "VERBOSE") == 0) || (strcmp(levelStr, "verbose") == 0)) + return Level::Verbose; + if ((strcmp(levelStr, "TRACE") == 0) || (strcmp(levelStr, "trace") == 0)) + return Level::Trace; + return Level::Unknown; + } + /// @brief Applies specified function to each level starting from startIndex + /// @param startIndex initial value to start the iteration from. This is passed as pointer and + /// is left-shifted so this can be used inside function (fn) to represent current level. + /// @param fn function to apply with each level. This bool represent whether or not to stop iterating through levels. + static inline void forEachLevel(base::type::EnumType* startIndex, const std::function& fn) { + base::type::EnumType lIndexMax = LevelHelper::kMaxValid; + do { + if (fn()) { + break; + } + *startIndex = static_cast(*startIndex << 1); + } while (*startIndex <= lIndexMax); + } +}; +/// @brief Represents enumeration of ConfigurationType used to configure or access certain aspect +/// of logging +enum class ConfigurationType : base::type::EnumType { + /// @brief Determines whether or not corresponding level and logger of logging is enabled + /// You may disable all logs by using el::Level::Global + Enabled = 1, + /// @brief Whether or not to write corresponding log to log file + ToFile = 2, + /// @brief Whether or not to write corresponding level and logger log to standard output. + /// By standard output meaning termnal, command prompt etc + ToStandardOutput = 4, + /// @brief Determines format of logging corresponding level and logger. + Format = 8, + /// @brief Determines log file (full path) to write logs to for correponding level and logger + Filename = 16, + /// @brief Specifies milliseconds width. Width can be within range (1-6) + MillisecondsWidth = 32, + /// @brief Determines whether or not performance tracking is enabled. + /// + /// @detail This does not depend on logger or level. Performance tracking always uses 'performance' logger + PerformanceTracking = 64, + /// @brief Specifies log file max size. + /// + /// @detail If file size of corresponding log file (for corresponding level) is >= specified size, log file will + /// be truncated and re-initiated. + MaxLogFileSize = 128, + /// @brief Specifies number of log entries to hold until we flush pending log data + LogFlushThreshold = 256, + /// @brief Represents unknown configuration + Unknown = 1010 +}; +/// @brief Static class that contains helper functions for el::ConfigurationType +class ConfigurationTypeHelper : base::StaticClass { +public: + /// @brief Represents minimum valid configuration type. Useful when iterating through enum. + static const base::type::EnumType kMinValid = static_cast(ConfigurationType::Enabled); + /// @brief Represents maximum valid configuration type. This is used internally and you should not need it. + static const base::type::EnumType kMaxValid = static_cast(ConfigurationType::MaxLogFileSize); + /// @brief Casts configuration type to int, useful for iterating through enum. + static base::type::EnumType castToInt(ConfigurationType configurationType) { + return static_cast(configurationType); + } + /// @brief Casts int(ushort) to configurationt type, useful for iterating through enum. + static ConfigurationType castFromInt(base::type::EnumType c) { + return static_cast(c); + } + /// @brief Converts configuration type to associated const char* + /// @returns Upper case string based configuration type. + static const char* convertToString(ConfigurationType configurationType) { + // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet. + if (configurationType == ConfigurationType::Enabled) return "ENABLED"; + if (configurationType == ConfigurationType::Filename) return "FILENAME"; + if (configurationType == ConfigurationType::Format) return "FORMAT"; + if (configurationType == ConfigurationType::ToFile) return "TO_FILE"; + if (configurationType == ConfigurationType::ToStandardOutput) return "TO_STANDARD_OUTPUT"; + if (configurationType == ConfigurationType::MillisecondsWidth) return "MILLISECONDS_WIDTH"; + if (configurationType == ConfigurationType::PerformanceTracking) return "PERFORMANCE_TRACKING"; + if (configurationType == ConfigurationType::MaxLogFileSize) return "MAX_LOG_FILE_SIZE"; + if (configurationType == ConfigurationType::LogFlushThreshold) return "LOG_FLUSH_THRESHOLD"; + return "UNKNOWN"; + } + /// @brief Converts from configStr to ConfigurationType + /// @param configStr Upper case string based configuration type. + /// Lower case is also valid but providing upper case is recommended. + static ConfigurationType convertFromString(const char* configStr) { + if ((strcmp(configStr, "ENABLED") == 0) || (strcmp(configStr, "enabled") == 0)) + return ConfigurationType::Enabled; + if ((strcmp(configStr, "TO_FILE") == 0) || (strcmp(configStr, "to_file") == 0)) + return ConfigurationType::ToFile; + if ((strcmp(configStr, "TO_STANDARD_OUTPUT") == 0) || (strcmp(configStr, "to_standard_output") == 0)) + return ConfigurationType::ToStandardOutput; + if ((strcmp(configStr, "FORMAT") == 0) || (strcmp(configStr, "format") == 0)) + return ConfigurationType::Format; + if ((strcmp(configStr, "FILENAME") == 0) || (strcmp(configStr, "filename") == 0)) + return ConfigurationType::Filename; + if ((strcmp(configStr, "MILLISECONDS_WIDTH") == 0) || (strcmp(configStr, "milliseconds_width") == 0)) + return ConfigurationType::MillisecondsWidth; + if ((strcmp(configStr, "PERFORMANCE_TRACKING") == 0) || (strcmp(configStr, "performance_tracking") == 0)) + return ConfigurationType::PerformanceTracking; + if ((strcmp(configStr, "MAX_LOG_FILE_SIZE") == 0) || (strcmp(configStr, "max_log_file_size") == 0)) + return ConfigurationType::MaxLogFileSize; + if ((strcmp(configStr, "LOG_FLUSH_THRESHOLD") == 0) || (strcmp(configStr, "log_flush_threshold") == 0)) + return ConfigurationType::LogFlushThreshold; + return ConfigurationType::Unknown; + } + /// @brief Applies specified function to each configuration type starting from startIndex + /// @param startIndex initial value to start the iteration from. This is passed by pointer and is left-shifted + /// so this can be used inside function (fn) to represent current configuration type. + /// @param fn function to apply with each configuration type. + /// This bool represent whether or not to stop iterating through configurations. + static inline void forEachConfigType(base::type::EnumType* startIndex, const std::function& fn) { + base::type::EnumType cIndexMax = ConfigurationTypeHelper::kMaxValid; + do { + if (fn()) { + break; + } + *startIndex = static_cast(*startIndex << 1); + } while (*startIndex <= cIndexMax); + } +}; +/// @brief Flags used while writing logs. This flags are set by user +enum class LoggingFlag : base::type::EnumType { + /// @brief Makes sure we have new line for each container log entry + NewLineForContainer = 1, + /// @brief Makes sure if -vmodule is used and does not specifies a module, then verbose + /// logging is allowed via that module. + AllowVerboseIfModuleNotSpecified = 2, + /// @brief When handling crashes by default, detailed crash reason will be logged as well + LogDetailedCrashReason = 4, + /// @brief Allows to disable application abortion when logged using FATAL level + DisableApplicationAbortOnFatalLog = 8, + /// @brief Flushes log with every log-entry (performance sensative) - Disabled by default + ImmediateFlush = 16, + /// @brief Enables strict file rolling + StrictLogFileSizeCheck = 32, + /// @brief Make terminal output colorful for supported terminals + ColoredTerminalOutput = 64, + /// @brief Supports use of multiple logging in same macro, e.g, CLOG(INFO, "default", "network") + MultiLoggerSupport = 128, + /// @brief Disables comparing performance tracker's checkpoints + DisablePerformanceTrackingCheckpointComparison = 256, + /// @brief Disable VModules + DisableVModules = 512, + /// @brief Disable VModules extensions + DisableVModulesExtensions = 1024, + /// @brief Enables hierarchical logging + HierarchicalLogging = 2048, + /// @brief Creates logger automatically when not available + CreateLoggerAutomatically = 4096, + /// @brief Adds spaces b/w logs that separated by left-shift operator + AutoSpacing = 8192, + /// @brief Preserves time format and does not convert it to sec, hour etc (performance tracking only) + FixedTimeFormat = 16384 +}; +namespace base { +/// @brief Namespace containing constants used internally. +namespace consts { + // Level log values - These are values that are replaced in place of %level format specifier + static const base::type::char_t* kInfoLevelLogValue = ELPP_LITERAL("INFO "); + static const base::type::char_t* kDebugLevelLogValue = ELPP_LITERAL("DEBUG"); + static const base::type::char_t* kWarningLevelLogValue = ELPP_LITERAL("WARN "); + static const base::type::char_t* kErrorLevelLogValue = ELPP_LITERAL("ERROR"); + static const base::type::char_t* kFatalLevelLogValue = ELPP_LITERAL("FATAL"); + static const base::type::char_t* kVerboseLevelLogValue = ELPP_LITERAL("VER"); + static const base::type::char_t* kTraceLevelLogValue = ELPP_LITERAL("TRACE"); + static const base::type::char_t* kInfoLevelShortLogValue = ELPP_LITERAL("I"); + static const base::type::char_t* kDebugLevelShortLogValue = ELPP_LITERAL("D"); + static const base::type::char_t* kWarningLevelShortLogValue = ELPP_LITERAL("W"); + static const base::type::char_t* kErrorLevelShortLogValue = ELPP_LITERAL("E"); + static const base::type::char_t* kFatalLevelShortLogValue = ELPP_LITERAL("F"); + static const base::type::char_t* kVerboseLevelShortLogValue = ELPP_LITERAL("V"); + static const base::type::char_t* kTraceLevelShortLogValue = ELPP_LITERAL("T"); + // Format specifiers - These are used to define log format + static const base::type::char_t* kAppNameFormatSpecifier = ELPP_LITERAL("%app"); + static const base::type::char_t* kLoggerIdFormatSpecifier = ELPP_LITERAL("%logger"); + static const base::type::char_t* kThreadIdFormatSpecifier = ELPP_LITERAL("%thread"); + static const base::type::char_t* kSeverityLevelFormatSpecifier = ELPP_LITERAL("%level"); + static const base::type::char_t* kSeverityLevelShortFormatSpecifier = ELPP_LITERAL("%levshort"); + static const base::type::char_t* kDateTimeFormatSpecifier = ELPP_LITERAL("%datetime"); + static const base::type::char_t* kLogFileFormatSpecifier = ELPP_LITERAL("%file"); + static const base::type::char_t* kLogFileBaseFormatSpecifier = ELPP_LITERAL("%fbase"); + static const base::type::char_t* kLogLineFormatSpecifier = ELPP_LITERAL("%line"); + static const base::type::char_t* kLogLocationFormatSpecifier = ELPP_LITERAL("%loc"); + static const base::type::char_t* kLogFunctionFormatSpecifier = ELPP_LITERAL("%func"); + static const base::type::char_t* kCurrentUserFormatSpecifier = ELPP_LITERAL("%user"); + static const base::type::char_t* kCurrentHostFormatSpecifier = ELPP_LITERAL("%host"); + static const base::type::char_t* kMessageFormatSpecifier = ELPP_LITERAL("%msg"); + static const base::type::char_t* kVerboseLevelFormatSpecifier = ELPP_LITERAL("%vlevel"); + static const char* kDateTimeFormatSpecifierForFilename = "%datetime"; + // Date/time + static const char* kDays[7] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; + static const char* kDaysAbbrev[7] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; + static const char* kMonths[12] = { "January", "February", "March", "Apri", "May", "June", "July", "August", + "September", "October", "November", "December" }; + static const char* kMonthsAbbrev[12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; + static const char* kDefaultDateTimeFormat = "%Y-%M-%d %H:%m:%s,%g"; + static const char* kDefaultDateTimeFormatInFilename = "%Y-%M-%d_%H-%m"; + static const int kYearBase = 1900; + static const char* kAm = "AM"; + static const char* kPm = "PM"; + // Miscellaneous constants + static const char* kDefaultLoggerId = "default"; + static const char* kPerformanceLoggerId = "performance"; + static const char* kSysLogLoggerId = "syslog"; + static const char* kNullPointer = "nullptr"; + static const char kFormatSpecifierChar = '%'; +#if ELPP_VARIADIC_TEMPLATES_SUPPORTED + static const char kFormatSpecifierCharValue = 'v'; +#endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED + static const unsigned int kMaxLogPerContainer = 100; + static const unsigned int kMaxLogPerCounter = 100000; + static const unsigned int kDefaultMillisecondsWidth = 3; + static const base::type::VerboseLevel kMaxVerboseLevel = 9; + static const char* kUnknownUser = "user"; + static const char* kUnknownHost = "unknown-host"; +#if defined(ELPP_DEFAULT_LOG_FILE) + static const char* kDefaultLogFile = ELPP_DEFAULT_LOG_FILE; +#else +# if ELPP_OS_UNIX +# if ELPP_OS_ANDROID + static const char* kDefaultLogFile = "logs/myeasylog.log"; +# else + static const char* kDefaultLogFile = "logs/myeasylog.log"; +# endif // ELPP_OS_ANDROID +# elif ELPP_OS_WINDOWS + static const char* kDefaultLogFile = "logs\\myeasylog.log"; +# endif // ELPP_OS_UNIX +#endif // defined(ELPP_DEFAULT_LOG_FILE) +#if !defined(ELPP_DISABLE_LOG_FILE_FROM_ARG) + static const char* kDefaultLogFileParam = "--default-log-file"; +#endif // !defined(ELPP_DISABLE_LOG_FILE_FROM_ARG) +#if defined(ELPP_LOGGING_FLAGS_FROM_ARG) + static const char* kLoggingFlagsParam = "--logging-flags"; +#endif // defined(ELPP_LOGGING_FLAGS_FROM_ARG) +#if ELPP_OS_WINDOWS + static const char* kFilePathSeperator = "\\"; +#else + static const char* kFilePathSeperator = "/"; +#endif // ELPP_OS_WINDOWS + static const char* kValidLoggerIdSymbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._"; + static const char* kConfigurationComment = "##"; + static const char* kConfigurationLevel = "*"; + static const char* kConfigurationLoggerId = "--"; + static const std::size_t kSourceFilenameMaxLength = 100; + static const std::size_t kSourceLineMaxLength = 10; + static const Level kPerformanceTrackerDefaultLevel = Level::Info; + const struct { + double value; + const base::type::char_t* unit; + } kTimeFormats[] = { + { 1000.0f, ELPP_LITERAL("mis") }, + { 1000.0f, ELPP_LITERAL("ms") }, + { 60.0f, ELPP_LITERAL("seconds") }, + { 60.0f, ELPP_LITERAL("minutes") }, + { 24.0f, ELPP_LITERAL("hours") }, + { 7.0f, ELPP_LITERAL("days") } + }; + static const int kTimeFormatsCount = sizeof(kTimeFormats) / sizeof(kTimeFormats[0]); + const struct { + int numb; + const char* name; + const char* brief; + const char* detail; + } kCrashSignals[] = { + // NOTE: Do not re-order, if you do please check CrashHandler(bool) constructor and CrashHandler::setHandler(..) + { SIGABRT, "SIGABRT", "Abnormal termination", + "Program was abnormally terminated." }, + { SIGFPE, "SIGFPE", "Erroneous arithmetic operation", + "Arithemetic operation issue such as division by zero or operation resulting in overflow." }, + { SIGILL, "SIGILL", "Illegal instruction", + "Generally due to a corruption in the code or to an attempt to execute data."}, + { SIGSEGV, "SIGSEGV", "Invalid access to memory", + "Program is trying to read an invalid (unallocated, deleted or corrupted) or inaccessible memory." }, + { SIGINT, "SIGINT", "Interactive attention signal", + "Interruption generated (generally) by user or operating system." }, + }; + static const int kCrashSignalsCount = sizeof(kCrashSignals) / sizeof(kCrashSignals[0]); +} // namespace consts +} // namespace base +typedef std::function PreRollOutCallback; +namespace base { +static inline void defaultPreRollOutCallback(const char*, std::size_t) {} +/// @brief Enum to represent timestamp unit +enum class TimestampUnit : base::type::EnumType { + Microsecond = 0, Millisecond = 1, Second = 2, Minute = 3, Hour = 4, Day = 5 +}; +/// @brief Format flags used to determine specifiers that are active for performance improvements. +enum class FormatFlags : base::type::EnumType { + DateTime = 1<<1, LoggerId = 1<<2, File = 1<<3, Line = 1<<4, Location = 1<<5, Function = 1<<6, + User = 1<<7, Host = 1<<8, LogMessage = 1<<9, VerboseLevel = 1<<10, AppName = 1<<11, ThreadId = 1<<12, + Level = 1<<13, FileBase = 1<<14, LevelShort = 1<<15 +}; +/// @brief A milliseconds width class containing actual width and offset for date/time +class MillisecondsWidth { +public: + MillisecondsWidth(void) { init(base::consts::kDefaultMillisecondsWidth); } + explicit MillisecondsWidth(int width) { init(width); } + bool operator==(const MillisecondsWidth& msWidth) { return m_width == msWidth.m_width && m_offset == msWidth.m_offset; } + int m_width; unsigned int m_offset; +private: + void init(int width) { + if (width < 1 || width > 6) { + width = base::consts::kDefaultMillisecondsWidth; + } + m_width = width; + switch (m_width) { + case 3: m_offset = 1000; break; + case 4: m_offset = 100; break; + case 5: m_offset = 10; break; + case 6: m_offset = 1; break; + default: m_offset = 1000; break; + } + } +}; +/// @brief Namespace containing utility functions/static classes used internally +namespace utils { +/// @brief Deletes memory safely and points to null +template +static inline +typename std::enable_if::value, void>::type +safeDelete(T*& pointer) { + if (pointer == nullptr) + return; + delete pointer; + pointer = nullptr; +} +/// @brief Gets value of const char* but if it is nullptr, a string nullptr is returned +static inline const char* charPtrVal(const char* pointer) { + return pointer == nullptr ? base::consts::kNullPointer : pointer; +} +/// @brief Aborts application due with user-defined status +static inline void abort(int status, const std::string& reason = std::string()) { + // Both status and reason params are there for debugging with tools like gdb etc + ELPP_UNUSED(status); + ELPP_UNUSED(reason); +#if defined(ELPP_COMPILER_MSVC) && defined(_M_IX86) && defined(_DEBUG) + // Ignore msvc critical error dialog - break instead (on debug mode) + _asm int 3 +#else + ::abort(); +#endif // defined(ELPP_COMPILER_MSVC) && defined(_M_IX86) && defined(_DEBUG) +} +/// @brief Bitwise operations for C++11 strong enum class. This casts e into Flag_T and returns value after bitwise operation +/// Use these function as 
flag = bitwise::Or(MyEnum::val1, flag);
+namespace bitwise { +template +static inline base::type::EnumType And(Enum e, base::type::EnumType flag) { + return static_cast(flag) & static_cast(e); +} +template +static inline base::type::EnumType Not(Enum e, base::type::EnumType flag) { + return static_cast(flag) & ~(static_cast(e)); +} +template +static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) { + return static_cast(flag) | static_cast(e); +} +} // namespace bitwise +template +static inline void addFlag(Enum e, base::type::EnumType* flag) { + *flag = base::utils::bitwise::Or(e, *flag); +} +template +static inline void removeFlag(Enum e, base::type::EnumType* flag) { + *flag = base::utils::bitwise::Not(e, *flag); +} +template +static inline bool hasFlag(Enum e, base::type::EnumType flag) { + return base::utils::bitwise::And(e, flag) > 0x0; +} +} // namespace utils +namespace threading { +#if ELPP_THREADING_ENABLED +# if !ELPP_USE_STD_THREADING +namespace internal { +/// @brief A mutex wrapper for compiler that dont yet support std::mutex +class Mutex : base::NoCopy { +public: + Mutex(void) { +# if ELPP_OS_UNIX + pthread_mutex_init(&m_underlyingMutex, nullptr); +# elif ELPP_OS_WINDOWS + InitializeCriticalSection(&m_underlyingMutex); +# endif // ELPP_OS_UNIX + } + + virtual ~Mutex(void) { +# if ELPP_OS_UNIX + pthread_mutex_destroy(&m_underlyingMutex); +# elif ELPP_OS_WINDOWS + DeleteCriticalSection(&m_underlyingMutex); +# endif // ELPP_OS_UNIX + } + + inline void lock(void) { +# if ELPP_OS_UNIX + pthread_mutex_lock(&m_underlyingMutex); +# elif ELPP_OS_WINDOWS + EnterCriticalSection(&m_underlyingMutex); +# endif // ELPP_OS_UNIX + } + + inline bool try_lock(void) { +# if ELPP_OS_UNIX + return (pthread_mutex_trylock(&m_underlyingMutex) == 0); +# elif ELPP_OS_WINDOWS + return TryEnterCriticalSection(&m_underlyingMutex); +# endif // ELPP_OS_UNIX + } + + inline void unlock(void) { +# if ELPP_OS_UNIX + pthread_mutex_unlock(&m_underlyingMutex); +# elif ELPP_OS_WINDOWS + LeaveCriticalSection(&m_underlyingMutex); +# endif // ELPP_OS_UNIX + } + +private: +# if ELPP_OS_UNIX + pthread_mutex_t m_underlyingMutex; +# elif ELPP_OS_WINDOWS + CRITICAL_SECTION m_underlyingMutex; +# endif // ELPP_OS_UNIX +}; +/// @brief Scoped lock for compiler that dont yet support std::lock_guard +template +class ScopedLock : base::NoCopy { +public: + explicit ScopedLock(M& mutex) { + m_mutex = &mutex; + m_mutex->lock(); + } + + virtual ~ScopedLock(void) { + m_mutex->unlock(); + } +private: + M* m_mutex; + ScopedLock(void); +}; +} // namespace internal +/// @brief Gets ID of currently running threading in windows systems. On unix, nothing is returned. +static inline std::string getCurrentThreadId(void) { + std::stringstream ss; +# if (ELPP_OS_WINDOWS) + ss << GetCurrentThreadId(); +# endif // (ELPP_OS_WINDOWS) + return ss.str(); +} +static inline void msleep(int) { + // No implementation for non std::thread version +} +typedef base::threading::internal::Mutex Mutex; +typedef base::threading::internal::ScopedLock ScopedLock; +# else +/// @brief Gets ID of currently running threading using std::this_thread::get_id() +static inline std::string getCurrentThreadId(void) { + std::stringstream ss; + ss << std::this_thread::get_id(); + return ss.str(); +} +static inline void msleep(int ms) { + // Only when async logging enabled - this is because async is strict on compiler +#if ELPP_ASYNC_LOGGING + std::this_thread::sleep_for(std::chrono::milliseconds(ms)); +#endif // ELPP_ASYNC_LOGGING +} +typedef std::mutex Mutex; +typedef std::lock_guard ScopedLock; +# endif // !ELPP_USE_STD_THREADING +#else +namespace internal { +/// @brief Mutex wrapper used when multi-threading is disabled. +class NoMutex : base::NoCopy { +public: + NoMutex(void) {} + inline void lock(void) {} + inline bool try_lock(void) { return true; } + inline void unlock(void) {} +}; +/// @brief Lock guard wrapper used when multi-threading is disabled. +template +class NoScopedLock : base::NoCopy { +public: + explicit NoScopedLock(Mutex&) { + } + virtual ~NoScopedLock(void) { + } +private: + NoScopedLock(void); +}; +} // namespace internal +static inline std::string getCurrentThreadId(void) { + return std::string(); +} +static inline void msleep(int) { + // No custom implementation +} +typedef base::threading::internal::NoMutex Mutex; +typedef base::threading::internal::NoScopedLock ScopedLock; +#endif // ELPP_THREADING_ENABLED +/// @brief Base of thread safe class, this class is inheritable-only +class ThreadSafe { +public: + virtual inline void acquireLock(void) ELPP_FINAL { m_mutex.lock(); } + virtual inline void releaseLock(void) ELPP_FINAL { m_mutex.unlock(); } + virtual inline base::threading::Mutex& lock(void) ELPP_FINAL { return m_mutex; } +protected: + ThreadSafe(void) {} + virtual ~ThreadSafe(void) {} +private: + base::threading::Mutex m_mutex; +}; +} // namespace threading +namespace utils { +class File : base::StaticClass { +public: + /// @brief Creates new out file stream for specified filename. + /// @return Pointer to newly created fstream or nullptr + static base::type::fstream_t* newFileStream(const std::string& filename) { + base::type::fstream_t *fs = new base::type::fstream_t(filename.c_str(), + base::type::fstream_t::out | base::type::fstream_t::app); +#if defined(ELPP_UNICODE) + std::locale elppUnicodeLocale(""); +#if ELPP_OS_WINDOWS + std::locale elppUnicodeLocaleWindows(elppUnicodeLocale, new std::codecvt_utf8_utf16); + elppUnicodeLocale = elppUnicodeLocaleWindows; +#endif + fs->imbue(elppUnicodeLocale); +#endif // defined(ELPP_UNICODE) + if (fs->is_open()) { + fs->flush(); + } else { + base::utils::safeDelete(fs); + ELPP_INTERNAL_ERROR("Bad file [" << filename << "]", true); + } + return fs; + } + + /// @brief Gets size of file provided in stream + static std::size_t getSizeOfFile(base::type::fstream_t* fs) { + if (fs == nullptr) { + return 0; + } + std::streampos currPos = fs->tellg(); + fs->seekg(0, fs->end); + std::size_t size = static_cast(fs->tellg()); + fs->seekg(currPos); + return size; + } + + /// @brief Determines whether or not provided path exist in current file system + static inline bool pathExists(const char* path, bool considerFile = false) { + if (path == nullptr) { + return false; + } +#if ELPP_OS_UNIX + ELPP_UNUSED(considerFile); + struct stat st; + return (stat(path, &st) == 0); +#elif ELPP_OS_WINDOWS + DWORD fileType = GetFileAttributesA(path); + if (fileType == INVALID_FILE_ATTRIBUTES) { + return false; + } + return considerFile ? true : ((fileType & FILE_ATTRIBUTE_DIRECTORY) == 0 ? false : true); +#endif // ELPP_OS_UNIX + } + + /// @brief Creates specified path on file system + /// @param path Path to create. + static bool createPath(const std::string& path) { + if (path.empty()) { + return false; + } + if (base::utils::File::pathExists(path.c_str())) { + return true; + } + int status = -1; + + char* currPath = const_cast(path.c_str()); + std::string builtPath = std::string(); +#if ELPP_OS_UNIX + if (path[0] == '/') { + builtPath = "/"; + } + currPath = STRTOK(currPath, base::consts::kFilePathSeperator, 0); +#elif ELPP_OS_WINDOWS + // Use secure functions API + char* nextTok_ = nullptr; + currPath = STRTOK(currPath, base::consts::kFilePathSeperator, &nextTok_); + ELPP_UNUSED(nextTok_); +#endif // ELPP_OS_UNIX + while (currPath != nullptr) { + builtPath.append(currPath); + builtPath.append(base::consts::kFilePathSeperator); +#if ELPP_OS_UNIX + status = mkdir(builtPath.c_str(), ELPP_LOG_PERMS); + currPath = STRTOK(nullptr, base::consts::kFilePathSeperator, 0); +#elif ELPP_OS_WINDOWS + status = _mkdir(builtPath.c_str()); + currPath = STRTOK(nullptr, base::consts::kFilePathSeperator, &nextTok_); +#endif // ELPP_OS_UNIX + } + if (status == -1) { + ELPP_INTERNAL_ERROR("Error while creating path [" << path << "]", true); + return false; + } + return true; + } + /// @brief Extracts path of filename with leading slash + static std::string extractPathFromFilename(const std::string& fullPath, + const char* seperator = base::consts::kFilePathSeperator) { + if ((fullPath == "") || (fullPath.find(seperator) == std::string::npos)) { + return fullPath; + } + std::size_t lastSlashAt = fullPath.find_last_of(seperator); + if (lastSlashAt == 0) { + return std::string(seperator); + } + return fullPath.substr(0, lastSlashAt + 1); + } + /// @brief builds stripped filename and puts it in buff + static void buildStrippedFilename(const char* filename, char buff[], + std::size_t limit = base::consts::kSourceFilenameMaxLength) { + std::size_t sizeOfFilename = strlen(filename); + if (sizeOfFilename >= limit) { + filename += (sizeOfFilename - limit); + if (filename[0] != '.' && filename[1] != '.') { // prepend if not already + filename += 3; // 3 = '..' + STRCAT(buff, "..", limit); + } + } + STRCAT(buff, filename, limit); + } + /// @brief builds base filename and puts it in buff + static void buildBaseFilename(const std::string& fullPath, char buff[], + std::size_t limit = base::consts::kSourceFilenameMaxLength, + const char* seperator = base::consts::kFilePathSeperator) { + const char *filename = fullPath.c_str(); + std::size_t lastSlashAt = fullPath.find_last_of(seperator); + filename += lastSlashAt ? lastSlashAt+1 : 0; + std::size_t sizeOfFilename = strlen(filename); + if (sizeOfFilename >= limit) { + filename += (sizeOfFilename - limit); + if (filename[0] != '.' && filename[1] != '.') { // prepend if not already + filename += 3; // 3 = '..' + STRCAT(buff, "..", limit); + } + } + STRCAT(buff, filename, limit); + } +}; +/// @brief String utilities helper class used internally. You should not use it. +class Str : base::StaticClass { +public: + /// @brief Checks if character is digit. Dont use libc implementation of it to prevent locale issues. + static inline bool isDigit(char c) { + return c >= '0' && c <= '9'; + } + + /// @brief Matches wildcards, '*' and '?' only supported. + static bool wildCardMatch(const char* str, const char* pattern) { + while (*pattern) { + switch (*pattern) { + case '?': + if (!*str) + return false; + ++str; + ++pattern; + break; + case '*': + if (wildCardMatch(str, pattern + 1)) + return true; + if (*str && wildCardMatch(str + 1, pattern)) + return true; + return false; + break; + default: + if (*str++ != *pattern++) + return false; + break; + } + } + return !*str && !*pattern; + } + + /// @brief Trims string from start + /// @param [in,out] str String to trim + static inline std::string& ltrim(std::string& str) { + str.erase(str.begin(), std::find_if(str.begin(), str.end(), std::not1(std::ptr_fun(&std::isspace)))); + return str; + } + + /// @brief Trim string from end + /// @param [in,out] str String to trim + static inline std::string& rtrim(std::string& str) { + str.erase(std::find_if(str.rbegin(), str.rend(), std::not1(std::ptr_fun(&std::isspace))).base(), str.end()); + return str; + } + + /// @brief Trims string from left and right + /// @param [in,out] str String to trim + static inline std::string& trim(std::string& str) { + return ltrim(rtrim(str)); + } + + /// @brief Determines whether or not str starts with specified string + /// @param str String to check + /// @param start String to check against + /// @return Returns true if starts with specified string, false otherwise + static inline bool startsWith(const std::string& str, const std::string& start) { + return (str.length() >= start.length()) && (str.compare(0, start.length(), start) == 0); + } + + /// @brief Determines whether or not str ends with specified string + /// @param str String to check + /// @param end String to check against + /// @return Returns true if ends with specified string, false otherwise + static inline bool endsWith(const std::string& str, const std::string& end) { + return (str.length() >= end.length()) && (str.compare(str.length() - end.length(), end.length(), end) == 0); + } + + /// @brief Replaces all instances of replaceWhat with 'replaceWith'. Original variable is changed for performance. + /// @param [in,out] str String to replace from + /// @param replaceWhat Character to replace + /// @param replaceWith Character to replace with + /// @return Modified version of str + static inline std::string& replaceAll(std::string& str, char replaceWhat, char replaceWith) { + std::replace(str.begin(), str.end(), replaceWhat, replaceWith); + return str; + } + + /// @brief Replaces all instances of 'replaceWhat' with 'replaceWith'. (String version) Replaces in place + /// @param str String to replace from + /// @param replaceWhat Character to replace + /// @param replaceWith Character to replace with + /// @return Modified (original) str + static inline std::string& replaceAll(std::string& str, const std::string& replaceWhat, // NOLINT + const std::string& replaceWith) { + if (replaceWhat == replaceWith) + return str; + std::size_t foundAt = std::string::npos; + while ((foundAt = str.find(replaceWhat, foundAt + 1)) != std::string::npos) { + str.replace(foundAt, replaceWhat.length(), replaceWith); + } + return str; + } + + static void replaceFirstWithEscape(base::type::string_t& str, const base::type::string_t& replaceWhat, // NOLINT + const base::type::string_t& replaceWith) { + std::size_t foundAt = base::type::string_t::npos; + while ((foundAt = str.find(replaceWhat, foundAt + 1)) != base::type::string_t::npos) { + if (foundAt > 0 && str[foundAt - 1] == base::consts::kFormatSpecifierChar) { + str.erase(foundAt > 0 ? foundAt - 1 : 0, 1); + ++foundAt; + } else { + str.replace(foundAt, replaceWhat.length(), replaceWith); + return; + } + } + } +#if defined(ELPP_UNICODE) + static void replaceFirstWithEscape(base::type::string_t& str, const base::type::string_t& replaceWhat, // NOLINT + const std::string& replaceWith) { + replaceFirstWithEscape(str, replaceWhat, base::type::string_t(replaceWith.begin(), replaceWith.end())); + } +#endif // defined(ELPP_UNICODE) + /// @brief Converts string to uppercase + /// @param str String to convert + /// @return Uppercase string + static inline std::string& toUpper(std::string& str) { + std::transform(str.begin(), str.end(), str.begin(), ::toupper); + return str; + } + + /// @brief Compares cstring equality - uses strcmp + static inline bool cStringEq(const char* s1, const char* s2) { + if (s1 == nullptr && s2 == nullptr) return true; + if (s1 == nullptr || s2 == nullptr) return false; + return strcmp(s1, s2) == 0; + } + + /// @brief Compares cstring equality (case-insensitive) - uses toupper(char) + /// Dont use strcasecmp because of CRT (VC++) + static bool cStringCaseEq(const char* s1, const char* s2) { + if (s1 == nullptr && s2 == nullptr) return true; + if (s1 == nullptr || s2 == nullptr) return false; + if (strlen(s1) != strlen(s2)) return false; + while (*s1 != '\0' && *s2 != '\0') { + if (::toupper(*s1) != ::toupper(*s2)) return false; + ++s1; + ++s2; + } + return true; + } + + /// @brief Returns true if c exist in str + static inline bool contains(const char* str, char c) { + for (; *str; ++str) { + if (*str == c) + return true; + } + return false; + } + + static inline char* convertAndAddToBuff(std::size_t n, int len, char* buf, const char* bufLim, bool zeroPadded = true) { + char localBuff[10] = ""; + char* p = localBuff + sizeof(localBuff) - 2; + if (n > 0) { + for (; n > 0 && p > localBuff && len > 0; n /= 10, --len) + *--p = static_cast(n % 10 + '0'); + } else { + *--p = '0'; + --len; + } + if (zeroPadded) + while (p > localBuff && len-- > 0) *--p = static_cast('0'); + return addToBuff(p, buf, bufLim); + } + + static inline char* addToBuff(const char* str, char* buf, const char* bufLim) { + while ((buf < bufLim) && ((*buf = *str++) != '\0')) + ++buf; + return buf; + } + + static inline char* clearBuff(char buff[], std::size_t lim) { + STRCPY(buff, "", lim); + ELPP_UNUSED(lim); // For *nix we dont have anything using lim in above STRCPY macro + return buff; + } + + /// @brief Converst wchar* to char* + /// NOTE: Need to free return value after use! + static char* wcharPtrToCharPtr(const wchar_t* line) { + std::size_t len_ = wcslen(line) + 1; + char* buff_ = static_cast(malloc(len_ + 1)); +# if ELPP_OS_UNIX || (ELPP_OS_WINDOWS && !ELPP_CRT_DBG_WARNINGS) + std::wcstombs(buff_, line, len_); +# elif ELPP_OS_WINDOWS + std::size_t convCount_ = 0; + mbstate_t mbState_; + ::memset(static_cast(&mbState_), 0, sizeof(mbState_)); + wcsrtombs_s(&convCount_, buff_, len_, &line, len_, &mbState_); +# endif // ELPP_OS_UNIX || (ELPP_OS_WINDOWS && !ELPP_CRT_DBG_WARNINGS) + return buff_; + } +}; +/// @brief Operating System helper static class used internally. You should not use it. +class OS : base::StaticClass { +public: +#if ELPP_OS_WINDOWS + /// @brief Gets environment variables for Windows based OS. + /// We are not using getenv(const char*) because of CRT deprecation + /// @param varname Variable name to get environment variable value for + /// @return If variable exist the value of it otherwise nullptr + static const char* getWindowsEnvironmentVariable(const char* varname) { + const DWORD bufferLen = 50; + static char buffer[bufferLen]; + if (GetEnvironmentVariableA(varname, buffer, bufferLen)) { + return buffer; + } + return nullptr; + } +#endif // ELPP_OS_WINDOWS +#if ELPP_OS_ANDROID + /// @brief Reads android property value + static inline std::string getProperty(const char* prop) { + char propVal[PROP_VALUE_MAX + 1]; + int ret = __system_property_get(prop, propVal); + return ret == 0 ? std::string() : std::string(propVal); + } + + /// @brief Reads android device name + static std::string getDeviceName(void) { + std::stringstream ss; + std::string manufacturer = getProperty("ro.product.manufacturer"); + std::string model = getProperty("ro.product.model"); + if (manufacturer.empty() || model.empty()) { + return std::string(); + } + ss << manufacturer << "-" << model; + return ss.str(); + } +#endif // ELPP_OS_ANDROID + + /// @brief Runs command on terminal and returns the output. + /// + /// @detail This is applicable only on unix based systems, for all other OS, an empty string is returned. + /// @param command Bash command + /// @return Result of bash output or empty string if no result found. + static const std::string getBashOutput(const char* command) { +#if (ELPP_OS_UNIX && !ELPP_OS_ANDROID && !ELPP_CYGWIN) + if (command == nullptr) { + return std::string(); + } + FILE* proc = nullptr; + if ((proc = popen(command, "r")) == nullptr) { + ELPP_INTERNAL_ERROR("\nUnable to run command [" << command << "]", true); + return std::string(); + } + char hBuff[4096]; + if (fgets(hBuff, sizeof(hBuff), proc) != nullptr) { + pclose(proc); + if (hBuff[strlen(hBuff) - 1] == '\n') { + hBuff[strlen(hBuff) - 1] = '\0'; + } + return std::string(hBuff); + } + return std::string(); +#else + ELPP_UNUSED(command); + return std::string(); +#endif // (ELPP_OS_UNIX && !ELPP_OS_ANDROID && !ELPP_CYGWIN) + } + + /// @brief Gets environment variable. This is cross-platform and CRT safe (for VC++) + /// @param variableName Environment variable name + /// @param defaultVal If no environment variable or value found the value to return by default + /// @param alternativeBashCommand If environment variable not found what would be alternative bash command + /// in order to look for value user is looking for. E.g, for 'user' alternative command will 'whoami' + static std::string getEnvironmentVariable(const char* variableName, const char* defaultVal, const char* alternativeBashCommand = nullptr) { +#if ELPP_OS_UNIX + const char* val = getenv(variableName); +#elif ELPP_OS_WINDOWS + const char* val = getWindowsEnvironmentVariable(variableName); +#endif // ELPP_OS_UNIX + if ((val == nullptr) || ((strcmp(val, "") == 0))) { +#if ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH) + // Try harder on unix-based systems + std::string valBash = base::utils::OS::getBashOutput(alternativeBashCommand); + if (valBash.empty()) { + return std::string(defaultVal); + } else { + return valBash; + } +#elif ELPP_OS_WINDOWS || ELPP_OS_UNIX + ELPP_UNUSED(alternativeBashCommand); + return std::string(defaultVal); +#endif // ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH) + } + return std::string(val); + } + /// @brief Gets current username. + static inline std::string currentUser(void) { +#if ELPP_OS_UNIX && !ELPP_OS_ANDROID + return getEnvironmentVariable("USER", base::consts::kUnknownUser, "whoami"); +#elif ELPP_OS_WINDOWS + return getEnvironmentVariable("USERNAME", base::consts::kUnknownUser); +#elif ELPP_OS_ANDROID + ELPP_UNUSED(base::consts::kUnknownUser); + return std::string("android"); +#else + return std::string(); +#endif // ELPP_OS_UNIX && !ELPP_OS_ANDROID + } + + /// @brief Gets current host name or computer name. + /// + /// @detail For android systems this is device name with its manufacturer and model seperated by hyphen + static inline std::string currentHost(void) { +#if ELPP_OS_UNIX && !ELPP_OS_ANDROID + return getEnvironmentVariable("HOSTNAME", base::consts::kUnknownHost, "hostname"); +#elif ELPP_OS_WINDOWS + return getEnvironmentVariable("COMPUTERNAME", base::consts::kUnknownHost); +#elif ELPP_OS_ANDROID + ELPP_UNUSED(base::consts::kUnknownHost); + return getDeviceName(); +#else + return std::string(); +#endif // ELPP_OS_UNIX && !ELPP_OS_ANDROID + } + /// @brief Whether or not terminal supports colors + static inline bool termSupportsColor(void) { + std::string term = getEnvironmentVariable("TERM", ""); + return term == "xterm" || term == "xterm-color" || term == "xterm-256color" || + term == "screen" || term == "linux" || term == "cygwin"; + } +}; +extern std::string s_currentUser; +extern std::string s_currentHost; +extern bool s_termSupportsColor; +#define ELPP_INITI_BASIC_DECLR \ + namespace el {\ + namespace base {\ + namespace utils {\ + std::string s_currentUser = el::base::utils::OS::currentUser(); \ + std::string s_currentHost = el::base::utils::OS::currentHost(); \ + bool s_termSupportsColor = el::base::utils::OS::termSupportsColor(); \ + }\ + }\ + } +/// @brief Contains utilities for cross-platform date/time. This class make use of el::base::utils::Str +class DateTime : base::StaticClass { +public: + /// @brief Cross platform gettimeofday for Windows and unix platform. This can be used to determine current millisecond. + /// + /// @detail For unix system it uses gettimeofday(timeval*, timezone*) and for Windows, a seperate implementation is provided + /// @param [in,out] tv Pointer that gets updated + static void gettimeofday(struct timeval* tv) { +#if ELPP_OS_WINDOWS + if (tv != nullptr) { +# if ELPP_COMPILER_MSVC || defined(_MSC_EXTENSIONS) + const unsigned __int64 delta_ = 11644473600000000Ui64; +# else + const unsigned __int64 delta_ = 11644473600000000ULL; +# endif // ELPP_COMPILER_MSVC || defined(_MSC_EXTENSIONS) + const double secOffSet = 0.000001; + const unsigned long usecOffSet = 1000000; + FILETIME fileTime; + GetSystemTimeAsFileTime(&fileTime); + unsigned __int64 present = 0; + present |= fileTime.dwHighDateTime; + present = present << 32; + present |= fileTime.dwLowDateTime; + present /= 10; // mic-sec + // Subtract the difference + present -= delta_; + tv->tv_sec = static_cast(present * secOffSet); + tv->tv_usec = static_cast(present % usecOffSet); + } +#else + ::gettimeofday(tv, nullptr); +#endif // ELPP_OS_WINDOWS + } + + /// @brief Gets current date and time with milliseconds. + /// @param format User provided date/time format + /// @param msWidth A pointer to base::MillisecondsWidth from configuration (non-null) + /// @returns string based date time in specified format. + static inline std::string getDateTime(const char* format, const base::MillisecondsWidth* msWidth) { + struct timeval currTime; + gettimeofday(&currTime); + struct ::tm timeInfo; + buildTimeInfo(&currTime, &timeInfo); + const int kBuffSize = 30; + char buff_[kBuffSize] = ""; + parseFormat(buff_, kBuffSize, format, &timeInfo, static_cast(currTime.tv_usec / msWidth->m_offset), msWidth); + return std::string(buff_); + } + + /// @brief Formats time to get unit accordingly, units like second if > 1000 or minutes if > 60000 etc + static base::type::string_t formatTime(unsigned long long time, base::TimestampUnit timestampUnit) { + double result = static_cast(time); + base::type::EnumType start = static_cast(timestampUnit); + const base::type::char_t* unit = base::consts::kTimeFormats[start].unit; + for (base::type::EnumType i = start; i < base::consts::kTimeFormatsCount - 1; ++i) { + if (result <= base::consts::kTimeFormats[i].value) { + break; + } + result /= base::consts::kTimeFormats[i].value; + unit = base::consts::kTimeFormats[i + 1].unit; + } + base::type::stringstream_t ss; + ss << result << " " << unit; + return ss.str(); + } + + /// @brief Gets time difference in milli/micro second depending on timestampUnit + static inline unsigned long long getTimeDifference(const struct timeval& endTime, const struct timeval& startTime, base::TimestampUnit timestampUnit) { + if (timestampUnit == base::TimestampUnit::Microsecond) { + return static_cast(static_cast(1000000 * endTime.tv_sec + endTime.tv_usec) - + static_cast(1000000 * startTime.tv_sec + startTime.tv_usec)); + } else { + return static_cast((((endTime.tv_sec - startTime.tv_sec) * 1000000) + (endTime.tv_usec - startTime.tv_usec)) / 1000); + } + } + +private: + static inline struct ::tm* buildTimeInfo(struct timeval* currTime, struct ::tm* timeInfo) { +#if ELPP_OS_UNIX + time_t rawTime = currTime->tv_sec; + ::localtime_r(&rawTime, timeInfo); + return timeInfo; +#else +# if ELPP_COMPILER_MSVC + ELPP_UNUSED(currTime); + time_t t; + _time64(&t); + localtime_s(timeInfo, &t); + return timeInfo; +# else + // For any other compilers that don't have CRT warnings issue e.g, MinGW or TDM GCC- we use different method + time_t rawTime = currTime->tv_sec; + struct tm* tmInf = localtime(&rawTime); + *timeInfo = *tmInf; + return timeInfo; +# endif // ELPP_COMPILER_MSVC +#endif // ELPP_OS_UNIX + } + static char* parseFormat(char* buf, std::size_t bufSz, const char* format, const struct tm* tInfo, + std::size_t msec, const base::MillisecondsWidth* msWidth) { + const char* bufLim = buf + bufSz; + for (; *format; ++format) { + if (*format == base::consts::kFormatSpecifierChar) { + switch (*++format) { + case base::consts::kFormatSpecifierChar: // Escape + break; + case '\0': // End + --format; + break; + case 'd': // Day + buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_mday, 2, buf, bufLim); + continue; + case 'a': // Day of week (short) + buf = base::utils::Str::addToBuff(base::consts::kDaysAbbrev[tInfo->tm_wday], buf, bufLim); + continue; + case 'A': // Day of week (long) + buf = base::utils::Str::addToBuff(base::consts::kDays[tInfo->tm_wday], buf, bufLim); + continue; + case 'M': // month + buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_mon + 1, 2, buf, bufLim); + continue; + case 'b': // month (short) + buf = base::utils::Str::addToBuff(base::consts::kMonthsAbbrev[tInfo->tm_mon], buf, bufLim); + continue; + case 'B': // month (long) + buf = base::utils::Str::addToBuff(base::consts::kMonths[tInfo->tm_mon], buf, bufLim); + continue; + case 'y': // year (two digits) + buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_year + base::consts::kYearBase, 2, buf, bufLim); + continue; + case 'Y': // year (four digits) + buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_year + base::consts::kYearBase, 4, buf, bufLim); + continue; + case 'h': // hour (12-hour) + buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_hour % 12, 2, buf, bufLim); + continue; + case 'H': // hour (24-hour) + buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_hour, 2, buf, bufLim); + continue; + case 'm': // minute + buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_min, 2, buf, bufLim); + continue; + case 's': // second + buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_sec, 2, buf, bufLim); + continue; + case 'z': // milliseconds + case 'g': + buf = base::utils::Str::convertAndAddToBuff(msec, msWidth->m_width, buf, bufLim); + continue; + case 'F': // AM/PM + buf = base::utils::Str::addToBuff((tInfo->tm_hour >= 12) ? base::consts::kPm : base::consts::kAm, buf, bufLim); + continue; + default: + continue; + } + } + if (buf == bufLim) break; + *buf++ = *format; + } + return buf; + } +}; +/// @brief Command line arguments for application if specified using el::Helpers::setArgs(..) or START_EASYLOGGINGPP(..) +class CommandLineArgs { +public: + CommandLineArgs(void) { + setArgs(0, static_cast(nullptr)); + } + CommandLineArgs(int argc, const char** argv) { + setArgs(argc, argv); + } + CommandLineArgs(int argc, char** argv) { + setArgs(argc, argv); + } + virtual ~CommandLineArgs(void) {} + /// @brief Sets arguments and parses them + inline void setArgs(int argc, const char** argv) { + setArgs(argc, const_cast(argv)); + } + /// @brief Sets arguments and parses them + inline void setArgs(int argc, char** argv) { + m_params.clear(); + m_paramsWithValue.clear(); + if (argc == 0 || argv == nullptr) { + return; + } + m_argc = argc; + m_argv = argv; + for (int i = 1; i < m_argc; ++i) { + const char* v = (strstr(m_argv[i], "=")); + if (v != nullptr && strlen(v) > 0) { + std::string key = std::string(m_argv[i]); + key = key.substr(0, key.find_first_of('=')); + if (hasParamWithValue(key.c_str())) { + ELPP_INTERNAL_INFO(1, "Skipping [" << key << "] arg since it already has value [" + << getParamValue(key.c_str()) << "]"); + } else { + m_paramsWithValue.insert(std::make_pair(key, std::string(v + 1))); + } + } + if (v == nullptr) { + if (hasParam(m_argv[i])) { + ELPP_INTERNAL_INFO(1, "Skipping [" << m_argv[i] << "] arg since it already exists"); + } else { + m_params.push_back(std::string(m_argv[i])); + } + } + } + } + /// @brief Returns true if arguments contain paramKey with a value (seperated by '=') + inline bool hasParamWithValue(const char* paramKey) const { + return m_paramsWithValue.find(std::string(paramKey)) != m_paramsWithValue.end(); + } + /// @brief Returns value of arguments + /// @see hasParamWithValue(const char*) + inline const char* getParamValue(const char* paramKey) const { + return m_paramsWithValue.find(std::string(paramKey))->second.c_str(); + } + /// @brief Return true if arguments has a param (not having a value) i,e without '=' + inline bool hasParam(const char* paramKey) const { + return std::find(m_params.begin(), m_params.end(), std::string(paramKey)) != m_params.end(); + } + /// @brief Returns true if no params available. This exclude argv[0] + inline bool empty(void) const { + return m_params.empty() && m_paramsWithValue.empty(); + } + /// @brief Returns total number of arguments. This exclude argv[0] + inline std::size_t size(void) const { + return m_params.size() + m_paramsWithValue.size(); + } + inline friend base::type::ostream_t& operator<<(base::type::ostream_t& os, const CommandLineArgs& c) { + for (int i = 1; i < c.m_argc; ++i) { + os << ELPP_LITERAL("[") << c.m_argv[i] << ELPP_LITERAL("]"); + if (i < c.m_argc - 1) { + os << ELPP_LITERAL(" "); + } + } + return os; + } + +private: + int m_argc; + char** m_argv; + std::map m_paramsWithValue; + std::vector m_params; +}; +/// @brief Abstract registry (aka repository) that provides basic interface for pointer repository specified by T_Ptr type. +/// +/// @detail Most of the functions are virtual final methods but anything implementing this abstract class should implement +/// unregisterAll() and deepCopy(const AbstractRegistry&) and write registerNew() method according to container +/// and few more methods; get() to find element, unregister() to unregister single entry. +/// Please note that this is thread-unsafe and should also implement thread-safety mechanisms in implementation. +template +class AbstractRegistry : public base::threading::ThreadSafe { +public: + typedef typename Container::iterator iterator; + typedef typename Container::const_iterator const_iterator; + + /// @brief Default constructor + AbstractRegistry(void) {} + + /// @brief Move constructor that is useful for base classes + AbstractRegistry(AbstractRegistry&& sr) { + if (this == &sr) { + return; + } + unregisterAll(); + m_list = std::move(sr.m_list); + } + + bool operator==(const AbstractRegistry& other) { + if (size() != other.size()) { + return false; + } + for (std::size_t i = 0; i < m_list.size(); ++i) { + if (m_list.at(i) != other.m_list.at(i)) { + return false; + } + } + return true; + } + + bool operator!=(const AbstractRegistry& other) { + if (size() != other.size()) { + return true; + } + for (std::size_t i = 0; i < m_list.size(); ++i) { + if (m_list.at(i) != other.m_list.at(i)) { + return true; + } + } + return false; + } + + /// @brief Assignment move operator + AbstractRegistry& operator=(AbstractRegistry&& sr) { + if (this == &sr) { + return *this; + } + unregisterAll(); + m_list = std::move(sr.m_list); + return *this; + } + + virtual ~AbstractRegistry(void) { + } + + /// @return Iterator pointer from start of repository + virtual inline iterator begin(void) ELPP_FINAL { + return m_list.begin(); + } + + /// @return Iterator pointer from end of repository + virtual inline iterator end(void) ELPP_FINAL { + return m_list.end(); + } + + + /// @return Constant iterator pointer from start of repository + virtual inline const_iterator cbegin(void) const ELPP_FINAL { + return m_list.cbegin(); + } + + /// @return End of repository + virtual inline const_iterator cend(void) const ELPP_FINAL { + return m_list.cend(); + } + + /// @return Whether or not repository is empty + virtual inline bool empty(void) const ELPP_FINAL { + return m_list.empty(); + } + + /// @return Size of repository + virtual inline std::size_t size(void) const ELPP_FINAL { + return m_list.size(); + } + + /// @brief Returns underlying container by reference + virtual inline Container& list(void) ELPP_FINAL { + return m_list; + } + + /// @brief Returns underlying container by constant reference. + virtual inline const Container& list(void) const ELPP_FINAL { + return m_list; + } + + /// @brief Unregisters all the pointers from current repository. + virtual void unregisterAll(void) = 0; + +protected: + virtual void deepCopy(const AbstractRegistry&) = 0; + void reinitDeepCopy(const AbstractRegistry& sr) { + unregisterAll(); + deepCopy(sr); + } + +private: + Container m_list; +}; + +/// @brief A pointer registry mechanism to manage memory and provide search functionalities. (non-predicate version) +/// +/// @detail NOTE: This is thread-unsafe implementation (although it contains lock function, it does not use these functions) +/// of AbstractRegistry. Any implementation of this class should be +/// explicitly (by using lock functions) +template +class Registry : public AbstractRegistry> { +public: + typedef typename Registry::iterator iterator; + typedef typename Registry::const_iterator const_iterator; + + Registry(void) {} + + /// @brief Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor. + Registry(const Registry& sr) : AbstractRegistry>() { + if (this == &sr) { + return; + } + this->reinitDeepCopy(sr); + } + + /// @brief Assignment operator that unregisters all the existing registeries and deeply copies each of repo element + /// @see unregisterAll() + /// @see deepCopy(const AbstractRegistry&) + Registry& operator=(const Registry& sr) { + if (this == &sr) { + return *this; + } + this->reinitDeepCopy(sr); + return *this; + } + + virtual ~Registry(void) { + unregisterAll(); + } + +protected: + virtual inline void unregisterAll(void) ELPP_FINAL { + if (!this->empty()) { + for (auto&& curr : this->list()) { + base::utils::safeDelete(curr.second); + } + this->list().clear(); + } + } + + /// @brief Registers new registry to repository. + virtual inline void registerNew(const T_Key& uniqKey, T_Ptr* ptr) ELPP_FINAL { + unregister(uniqKey); + this->list().insert(std::make_pair(uniqKey, ptr)); + } + + /// @brief Unregisters single entry mapped to specified unique key + inline void unregister(const T_Key& uniqKey) { + T_Ptr* existing = get(uniqKey); + if (existing != nullptr) { + base::utils::safeDelete(existing); + this->list().erase(uniqKey); + } + } + + /// @brief Gets pointer from repository. If none found, nullptr is returned. + inline T_Ptr* get(const T_Key& uniqKey) { + iterator it = this->list().find(uniqKey); + return it == this->list().end() + ? nullptr + : it->second; + } + +private: + virtual inline void deepCopy(const AbstractRegistry>& sr) ELPP_FINAL { + for (const_iterator it = sr.cbegin(); it != sr.cend(); ++it) { + registerNew(it->first, new T_Ptr(*it->second)); + } + } +}; + +/// @brief A pointer registry mechanism to manage memory and provide search functionalities. (predicate version) +/// +/// @detail NOTE: This is thread-unsafe implementation of AbstractRegistry. Any implementation of this class +/// should be made thread-safe explicitly +template +class RegistryWithPred : public AbstractRegistry> { +public: + typedef typename RegistryWithPred::iterator iterator; + typedef typename RegistryWithPred::const_iterator const_iterator; + + RegistryWithPred(void) { + } + + virtual ~RegistryWithPred(void) { + unregisterAll(); + } + + /// @brief Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor. + RegistryWithPred(const RegistryWithPred& sr) : AbstractRegistry>() { + if (this == &sr) { + return; + } + this->reinitDeepCopy(sr); + } + + /// @brief Assignment operator that unregisters all the existing registeries and deeply copies each of repo element + /// @see unregisterAll() + /// @see deepCopy(const AbstractRegistry&) + RegistryWithPred& operator=(const RegistryWithPred& sr) { + if (this == &sr) { + return *this; + } + this->reinitDeepCopy(sr); + return *this; + } + + friend inline base::type::ostream_t& operator<<(base::type::ostream_t& os, const RegistryWithPred& sr) { + for (const_iterator it = sr.list().begin(); it != sr.list().end(); ++it) { + os << ELPP_LITERAL(" ") << **it << ELPP_LITERAL("\n"); + } + return os; + } + +protected: + virtual inline void unregisterAll(void) ELPP_FINAL { + if (!this->empty()) { + for (auto&& curr : this->list()) { + base::utils::safeDelete(curr); + } + this->list().clear(); + } + } + + virtual void unregister(T_Ptr*& ptr) ELPP_FINAL { + if (ptr) { + iterator iter = this->begin(); + for (; iter != this->end(); ++iter) { + if (ptr == *iter) { + break; + } + } + if (iter != this->end() && *iter != nullptr) { + this->list().erase(iter); + base::utils::safeDelete(*iter); + } + } + } + + virtual inline void registerNew(T_Ptr* ptr) ELPP_FINAL { + this->list().push_back(ptr); + } + + /// @brief Gets pointer from repository with speicifed arguments. Arguments are passed to predicate + /// in order to validate pointer. + template + inline T_Ptr* get(const T& arg1, const T2 arg2) { + iterator iter = std::find_if(this->list().begin(), this->list().end(), Pred(arg1, arg2)); + if (iter != this->list().end() && *iter != nullptr) { + return *iter; + } + return nullptr; + } + +private: + virtual inline void deepCopy(const AbstractRegistry>& sr) { + for (const_iterator it = sr.list().begin(); it != sr.list().end(); ++it) { + registerNew(new T_Ptr(**it)); + } + } +}; + +} // namespace utils +} // namespace base +/// @brief Base of Easylogging++ friendly class +/// +/// @detail After inheriting this class publicly, implement pure-virtual function `void log(std::ostream&) const` +class Loggable { +public: + virtual ~Loggable(void) {} + virtual void log(el::base::type::ostream_t&) const = 0; +private: + friend inline el::base::type::ostream_t& operator<<(el::base::type::ostream_t& os, const Loggable& loggable) { + loggable.log(os); + return os; + } +}; +namespace base { +/// @brief Represents log format containing flags and date format. This is used internally to start initial log +class LogFormat : public Loggable { +public: + LogFormat(void) : + m_level(Level::Unknown), + m_userFormat(base::type::string_t()), + m_format(base::type::string_t()), + m_dateTimeFormat(std::string()), + m_flags(0x0) { + } + + LogFormat(Level level, const base::type::string_t& format) + : m_level(level), m_userFormat(format) { + parseFromFormat(m_userFormat); + } + + LogFormat(const LogFormat& logFormat) { + m_level = logFormat.m_level; + m_userFormat = logFormat.m_userFormat; + m_format = logFormat.m_format; + m_dateTimeFormat = logFormat.m_dateTimeFormat; + m_flags = logFormat.m_flags; + } + + LogFormat(LogFormat&& logFormat) { + m_level = std::move(logFormat.m_level); + m_userFormat = std::move(logFormat.m_userFormat); + m_format = std::move(logFormat.m_format); + m_dateTimeFormat = std::move(logFormat.m_dateTimeFormat); + m_flags = std::move(logFormat.m_flags); + } + + LogFormat& operator=(const LogFormat& logFormat) { + m_level = logFormat.m_level; + m_userFormat = logFormat.m_userFormat; + m_dateTimeFormat = logFormat.m_dateTimeFormat; + m_flags = logFormat.m_flags; + return *this; + } + + virtual ~LogFormat(void) { + } + + inline bool operator==(const LogFormat& other) { + return m_level == other.m_level && m_userFormat == other.m_userFormat && m_format == other.m_format && + m_dateTimeFormat == other.m_dateTimeFormat && m_flags == other.m_flags; + } + + /// @brief Updates format to be used while logging. + /// @param userFormat User provided format + void parseFromFormat(const base::type::string_t& userFormat) { + // We make copy because we will be changing the format + // i.e, removing user provided date format from original format + // and then storing it. + base::type::string_t formatCopy = userFormat; + m_flags = 0x0; + auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) { + std::size_t foundAt = base::type::string_t::npos; + while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos){ + if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) { + if (hasFlag(flag)) { + // If we already have flag we remove the escape chars so that '%%' is turned to '%' + // even after specifier resolution - this is because we only replaceFirst specifier + formatCopy.erase(foundAt > 0 ? foundAt - 1 : 0, 1); + ++foundAt; + } + } else { + if (!hasFlag(flag)) addFlag(flag); + } + } + }; + conditionalAddFlag(base::consts::kAppNameFormatSpecifier, base::FormatFlags::AppName); + conditionalAddFlag(base::consts::kSeverityLevelFormatSpecifier, base::FormatFlags::Level); + conditionalAddFlag(base::consts::kSeverityLevelShortFormatSpecifier, base::FormatFlags::LevelShort); + conditionalAddFlag(base::consts::kLoggerIdFormatSpecifier, base::FormatFlags::LoggerId); + conditionalAddFlag(base::consts::kThreadIdFormatSpecifier, base::FormatFlags::ThreadId); + conditionalAddFlag(base::consts::kLogFileFormatSpecifier, base::FormatFlags::File); + conditionalAddFlag(base::consts::kLogFileBaseFormatSpecifier, base::FormatFlags::FileBase); + conditionalAddFlag(base::consts::kLogLineFormatSpecifier, base::FormatFlags::Line); + conditionalAddFlag(base::consts::kLogLocationFormatSpecifier, base::FormatFlags::Location); + conditionalAddFlag(base::consts::kLogFunctionFormatSpecifier, base::FormatFlags::Function); + conditionalAddFlag(base::consts::kCurrentUserFormatSpecifier, base::FormatFlags::User); + conditionalAddFlag(base::consts::kCurrentHostFormatSpecifier, base::FormatFlags::Host); + conditionalAddFlag(base::consts::kMessageFormatSpecifier, base::FormatFlags::LogMessage); + conditionalAddFlag(base::consts::kVerboseLevelFormatSpecifier, base::FormatFlags::VerboseLevel); + // For date/time we need to extract user's date format first + std::size_t dateIndex = std::string::npos; + if ((dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier)) != std::string::npos) { + while (dateIndex > 0 && formatCopy[dateIndex - 1] == base::consts::kFormatSpecifierChar) { + dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier, dateIndex + 1); + } + if (dateIndex != std::string::npos) { + addFlag(base::FormatFlags::DateTime); + updateDateFormat(dateIndex, formatCopy); + } + } + m_format = formatCopy; + updateFormatSpec(); + } + + inline Level level(void) const { + return m_level; + } + + inline const base::type::string_t& userFormat(void) const { + return m_userFormat; + } + + inline const base::type::string_t& format(void) const { + return m_format; + } + + inline const std::string& dateTimeFormat(void) const { + return m_dateTimeFormat; + } + + inline base::type::EnumType flags(void) const { + return m_flags; + } + + inline bool hasFlag(base::FormatFlags flag) const { + return base::utils::hasFlag(flag, m_flags); + } + + virtual void log(el::base::type::ostream_t& os) const { + os << m_format; + } + +protected: + /// @brief Updates date time format if available in currFormat. + /// @param index Index where %datetime, %date or %time was found + /// @param [in,out] currFormat current format that is being used to format + virtual void updateDateFormat(std::size_t index, base::type::string_t& currFormat) ELPP_FINAL { + if (hasFlag(base::FormatFlags::DateTime)) { + index += ELPP_STRLEN(base::consts::kDateTimeFormatSpecifier); + } + const base::type::char_t* ptr = currFormat.c_str() + index; + if ((currFormat.size() > index) && (ptr[0] == '{')) { + // User has provided format for date/time + ++ptr; + int count = 1; // Start by 1 in order to remove starting brace + std::stringstream ss; + for (; *ptr; ++ptr, ++count) { + if (*ptr == '}') { + ++count; // In order to remove ending brace + break; + } + ss << *ptr; + } + currFormat.erase(index, count); + m_dateTimeFormat = ss.str(); + } else { + // No format provided, use default + if (hasFlag(base::FormatFlags::DateTime)) { + m_dateTimeFormat = std::string(base::consts::kDefaultDateTimeFormat); + } + } + } + + /// @brief Updates %level from format. This is so that we dont have to do it at log-writing-time. It uses m_format and m_level + virtual void updateFormatSpec(void) ELPP_FINAL { + // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet. + if (m_level == Level::Debug) { + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, + base::consts::kDebugLevelLogValue); + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, + base::consts::kDebugLevelShortLogValue); + } else if (m_level == Level::Info) { + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, + base::consts::kInfoLevelLogValue); + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, + base::consts::kInfoLevelShortLogValue); + } else if (m_level == Level::Warning) { + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, + base::consts::kWarningLevelLogValue); + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, + base::consts::kWarningLevelShortLogValue); + } else if (m_level == Level::Error) { + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, + base::consts::kErrorLevelLogValue); + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, + base::consts::kErrorLevelShortLogValue); + } else if (m_level == Level::Fatal) { + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, + base::consts::kFatalLevelLogValue); + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, + base::consts::kFatalLevelShortLogValue); + } else if (m_level == Level::Verbose) { + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, + base::consts::kVerboseLevelLogValue); + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, + base::consts::kVerboseLevelShortLogValue); + } else if (m_level == Level::Trace) { + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, + base::consts::kTraceLevelLogValue); + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, + base::consts::kTraceLevelShortLogValue); + } + if (hasFlag(base::FormatFlags::User)) { + std::string s = base::utils::s_currentUser; + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentUserFormatSpecifier, + base::utils::s_currentUser); + } + if (hasFlag(base::FormatFlags::Host)) { + base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentHostFormatSpecifier, + base::utils::s_currentHost); + } + // Ignore Level::Global and Level::Unknown + } + + inline void addFlag(base::FormatFlags flag) { + base::utils::addFlag(flag, &m_flags); + } + +private: + Level m_level; + base::type::string_t m_userFormat; + base::type::string_t m_format; + std::string m_dateTimeFormat; + base::type::EnumType m_flags; + friend class el::Logger; // To resolve loggerId format specifier easily +}; +} // namespace base +/// @brief Resolving function for format specifier +typedef std::function FormatSpecifierValueResolver; +/// @brief User-provided custom format specifier +/// @see el::Helpers::installCustomFormatSpecifier +/// @see FormatSpecifierValueResolver +class CustomFormatSpecifier { +public: + CustomFormatSpecifier(const char* formatSpecifier, const FormatSpecifierValueResolver& resolver) : + m_formatSpecifier(formatSpecifier), m_resolver(resolver) {} + inline const char* formatSpecifier(void) const { return m_formatSpecifier; } + inline const FormatSpecifierValueResolver& resolver(void) const { return m_resolver; } + inline bool operator==(const char* formatSpecifier) { + return strcmp(m_formatSpecifier, formatSpecifier) == 0; + } + +private: + const char* m_formatSpecifier; + FormatSpecifierValueResolver m_resolver; +}; +/// @brief Represents single configuration that has representing level, configuration type and a string based value. +/// +/// @detail String based value means any value either its boolean, integer or string itself, it will be embedded inside quotes +/// and will be parsed later. +/// +/// Consider some examples below: +/// * el::Configuration confEnabledInfo(el::Level::Info, el::ConfigurationType::Enabled, "true"); +/// * el::Configuration confMaxLogFileSizeInfo(el::Level::Info, el::ConfigurationType::MaxLogFileSize, "2048"); +/// * el::Configuration confFilenameInfo(el::Level::Info, el::ConfigurationType::Filename, "/var/log/my.log"); +class Configuration : public Loggable { +public: + Configuration(const Configuration& c) : + m_level(c.m_level), + m_configurationType(c.m_configurationType), + m_value(c.m_value) { + } + + Configuration& operator=(const Configuration& c) { + m_level = c.m_level; + m_configurationType = c.m_configurationType; + m_value = c.m_value; + return *this; + } + + virtual ~Configuration(void) { + } + + /// @brief Full constructor used to sets value of configuration + Configuration(Level level, ConfigurationType configurationType, const std::string& value) : + m_level(level), + m_configurationType(configurationType), + m_value(value) { + } + + /// @brief Gets level of current configuration + inline Level level(void) const { + return m_level; + } + + /// @brief Gets configuration type of current configuration + inline ConfigurationType configurationType(void) const { + return m_configurationType; + } + + /// @brief Gets string based configuration value + inline const std::string& value(void) const { + return m_value; + } + + /// @brief Set string based configuration value + /// @param value Value to set. Values have to be std::string; For boolean values use "true", "false", for any integral values + /// use them in quotes. They will be parsed when configuring + inline void setValue(const std::string& value) { + m_value = value; + } + + virtual inline void log(el::base::type::ostream_t& os) const { + os << LevelHelper::convertToString(m_level) + << ELPP_LITERAL(" ") << ConfigurationTypeHelper::convertToString(m_configurationType) + << ELPP_LITERAL(" = ") << m_value.c_str(); + } + + /// @brief Used to find configuration from configuration (pointers) repository. Avoid using it. + class Predicate { + public: + Predicate(Level level, ConfigurationType configurationType) : + m_level(level), + m_configurationType(configurationType) { + } + + inline bool operator()(const Configuration* conf) const { + return ((conf != nullptr) && (conf->level() == m_level) && (conf->configurationType() == m_configurationType)); + } + + private: + Level m_level; + ConfigurationType m_configurationType; + }; + +private: + Level m_level; + ConfigurationType m_configurationType; + std::string m_value; +}; + +/// @brief Thread-safe Configuration repository +/// +/// @detail This repository represents configurations for all the levels and configuration type mapped to a value. +class Configurations : public base::utils::RegistryWithPred { +public: + /// @brief Default constructor with empty repository + Configurations(void) : + m_configurationFile(std::string()), + m_isFromFile(false) { + } + + /// @brief Constructor used to set configurations using configuration file. + /// @param configurationFile Full path to configuration file + /// @param useDefaultsForRemaining Lets you set the remaining configurations to default. + /// @param base If provided, this configuration will be based off existing repository that this argument is pointing to. + /// @see parseFromFile(const std::string&, Configurations* base) + /// @see setRemainingToDefault() + Configurations(const std::string& configurationFile, bool useDefaultsForRemaining = true, Configurations* base = nullptr) : + m_configurationFile(configurationFile), + m_isFromFile(false) { + parseFromFile(configurationFile, base); + if (useDefaultsForRemaining) { + setRemainingToDefault(); + } + } + + virtual ~Configurations(void) { + } + + /// @brief Parses configuration from file. + /// @param configurationFile Full path to configuration file + /// @param base Configurations to base new configuration repository off. This value is used when you want to use + /// existing Configurations to base all the values and then set rest of configuration via configuration file. + /// @return True if successfully parsed, false otherwise. You may define 'ELPP_DEBUG_ASSERT_FAILURE' to make sure you + /// do not proceed without successful parse. + inline bool parseFromFile(const std::string& configurationFile, Configurations* base = nullptr) { + // We initial assertion with true because if we have assertion diabled, we want to pass this + // check and if assertion is enabled we will have values re-assigned any way. + bool assertionPassed = true; + ELPP_ASSERT((assertionPassed = base::utils::File::pathExists(configurationFile.c_str(), true)), + "Configuration file [" << configurationFile << "] does not exist!"); + if (!assertionPassed) { + return false; + } + bool success = Parser::parseFromFile(configurationFile, this, base); + m_isFromFile = success; + return success; + } + + /// @brief Parse configurations from configuration string. + /// + /// @detail This configuration string has same syntax as configuration file contents. Make sure all the necessary + /// new line characters are provided. + /// @param base Configurations to base new configuration repository off. This value is used when you want to use + /// existing Configurations to base all the values and then set rest of configuration via configuration text. + /// @return True if successfully parsed, false otherwise. You may define 'ELPP_DEBUG_ASSERT_FAILURE' to make sure you + /// do not proceed without successful parse. + inline bool parseFromText(const std::string& configurationsString, Configurations* base = nullptr) { + bool success = Parser::parseFromText(configurationsString, this, base); + if (success) { + m_isFromFile = false; + } + return success; + } + + /// @brief Sets configuration based-off an existing configurations. + /// @param base Pointer to existing configurations. + inline void setFromBase(Configurations* base) { + if (base == nullptr || base == this) { + return; + } + base::threading::ScopedLock scopedLock(base->lock()); + for (Configuration*& conf : base->list()) { + set(conf); + } + } + + /// @brief Determines whether or not specified configuration type exists in the repository. + /// + /// @detail Returns as soon as first level is found. + /// @param configurationType Type of configuration to check existence for. + bool hasConfiguration(ConfigurationType configurationType) { + base::type::EnumType lIndex = LevelHelper::kMinValid; + bool result = false; + LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { + if (hasConfiguration(LevelHelper::castFromInt(lIndex), configurationType)) { + result = true; + } + return result; + }); + return result; + } + + /// @brief Determines whether or not specified configuration type exists for specified level + /// @param level Level to check + /// @param configurationType Type of configuration to check existence for. + inline bool hasConfiguration(Level level, ConfigurationType configurationType) { + base::threading::ScopedLock scopedLock(lock()); +#if ELPP_COMPILER_INTEL + // We cant specify template types here, Intel C++ throws compilation error + // "error: type name is not allowed" + return RegistryWithPred::get(level, configurationType) != nullptr; +#else + return RegistryWithPred::get(level, configurationType) != nullptr; +#endif // ELPP_COMPILER_INTEL + } + + /// @brief Sets value of configuration for specified level. + /// + /// @detail Any existing configuration for specified level will be replaced. Also note that configuration types + /// ConfigurationType::MillisecondsWidth and ConfigurationType::PerformanceTracking will be ignored if not set for + /// Level::Global because these configurations are not dependant on level. + /// @param level Level to set configuration for (el::Level). + /// @param configurationType Type of configuration (el::ConfigurationType) + /// @param value A string based value. Regardless of what the data type of configuration is, it will always be string + /// from users' point of view. This is then parsed later to be used internally. + /// @see Configuration::setValue(const std::string& value) + /// @see el::Level + /// @see el::ConfigurationType + inline void set(Level level, ConfigurationType configurationType, const std::string& value) { + base::threading::ScopedLock scopedLock(lock()); + unsafeSet(level, configurationType, value); // This is not unsafe anymore as we have locked mutex + if (level == Level::Global) { + unsafeSetGlobally(configurationType, value, false); // Again this is not unsafe either + } + } + + /// @brief Sets single configuration based on other single configuration. + /// @see set(Level level, ConfigurationType configurationType, const std::string& value) + inline void set(Configuration* conf) { + if (conf == nullptr) { + return; + } + set(conf->level(), conf->configurationType(), conf->value()); + } + + inline Configuration* get(Level level, ConfigurationType configurationType) { + base::threading::ScopedLock scopedLock(lock()); + return RegistryWithPred::get(level, configurationType); + } + + /// @brief Sets configuration for all levels. + /// @param configurationType Type of configuration + /// @param value String based value + /// @see Configurations::set(Level level, ConfigurationType configurationType, const std::string& value) + inline void setGlobally(ConfigurationType configurationType, const std::string& value) { + setGlobally(configurationType, value, false); + } + + /// @brief Clears repository so that all the configurations are unset + inline void clear(void) { + base::threading::ScopedLock scopedLock(lock()); + unregisterAll(); + } + + /// @brief Gets configuration file used in parsing this configurations. + /// + /// @detail If this repository was set manually or by text this returns empty string. + inline const std::string& configurationFile(void) const { + return m_configurationFile; + } + + /// @brief Sets configurations to "factory based" configurations. + void setToDefault(void) { + setGlobally(ConfigurationType::Enabled, std::string("true"), true); +#if !defined(ELPP_NO_DEFAULT_LOG_FILE) + setGlobally(ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile), true); +#else + ELPP_UNUSED(base::consts::kDefaultLogFile); +#endif // !defined(ELPP_NO_DEFAULT_LOG_FILE) + setGlobally(ConfigurationType::ToFile, std::string("true"), true); + setGlobally(ConfigurationType::ToStandardOutput, std::string("true"), true); + setGlobally(ConfigurationType::MillisecondsWidth, std::string("3"), true); + setGlobally(ConfigurationType::PerformanceTracking, std::string("true"), true); + setGlobally(ConfigurationType::MaxLogFileSize, std::string("0"), true); + setGlobally(ConfigurationType::LogFlushThreshold, std::string("0"), true); + + setGlobally(ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"), true); + set(Level::Debug, ConfigurationType::Format, std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg")); + // INFO and WARNING are set to default by Level::Global + set(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); + set(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); + set(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg")); + set(Level::Trace, ConfigurationType::Format, std::string("%datetime %level [%logger] [%func] [%loc] %msg")); + } + + /// @brief Lets you set the remaining configurations to default. + /// + /// @detail By remaining, it means that the level/type a configuration does not exist for. + /// This function is useful when you want to minimize chances of failures, e.g, if you have a configuration file that sets + /// configuration for all the configurations except for Enabled or not, we use this so that ENABLED is set to default i.e, + /// true. If you dont do this explicitley (either by calling this function or by using second param in Constructor + /// and try to access a value, an error is thrown + void setRemainingToDefault(void) { + base::threading::ScopedLock scopedLock(lock()); + unsafeSetIfNotExist(Level::Global, ConfigurationType::Enabled, std::string("true")); +#if !defined(ELPP_NO_DEFAULT_LOG_FILE) + unsafeSetIfNotExist(Level::Global, ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile)); +#endif // !defined(ELPP_NO_DEFAULT_LOG_FILE) + unsafeSetIfNotExist(Level::Global, ConfigurationType::ToFile, std::string("true")); + unsafeSetIfNotExist(Level::Global, ConfigurationType::ToStandardOutput, std::string("true")); + unsafeSetIfNotExist(Level::Global, ConfigurationType::MillisecondsWidth, std::string("3")); + unsafeSetIfNotExist(Level::Global, ConfigurationType::PerformanceTracking, std::string("true")); + unsafeSetIfNotExist(Level::Global, ConfigurationType::MaxLogFileSize, std::string("0")); + unsafeSetIfNotExist(Level::Global, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); + unsafeSetIfNotExist(Level::Debug, ConfigurationType::Format, + std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg")); + // INFO and WARNING are set to default by Level::Global + unsafeSetIfNotExist(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); + unsafeSetIfNotExist(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); + unsafeSetIfNotExist(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg")); + unsafeSetIfNotExist(Level::Trace, ConfigurationType::Format, std::string("%datetime %level [%logger] [%func] [%loc] %msg")); + } + + /// @brief Parser used internally to parse configurations from file or text. + /// + /// @detail This class makes use of base::utils::Str. + /// You should not need this unless you are working on some tool for Easylogging++ + class Parser : base::StaticClass { + public: + /// @brief Parses configuration from file. + /// @param configurationFile Full path to configuration file + /// @param sender Sender configurations pointer. Usually 'this' is used from calling class + /// @param base Configurations to base new configuration repository off. This value is used when you want to use + /// existing Configurations to base all the values and then set rest of configuration via configuration file. + /// @return True if successfully parsed, false otherwise. You may define '_STOP_ON_FIRSTELPP_ASSERTION' to make sure you + /// do not proceed without successful parse. + static bool parseFromFile(const std::string& configurationFile, Configurations* sender, Configurations* base = nullptr) { + sender->setFromBase(base); + std::ifstream fileStream_(configurationFile.c_str(), std::ifstream::in); + ELPP_ASSERT(fileStream_.is_open(), "Unable to open configuration file [" << configurationFile << "] for parsing."); + bool parsedSuccessfully = false; + std::string line = std::string(); + Level currLevel = Level::Unknown; + std::string currConfigStr = std::string(); + std::string currLevelStr = std::string(); + while (fileStream_.good()) { + std::getline(fileStream_, line); + parsedSuccessfully = parseLine(&line, &currConfigStr, &currLevelStr, &currLevel, sender); + ELPP_ASSERT(parsedSuccessfully, "Unable to parse configuration line: " << line); + } + return parsedSuccessfully; + } + + /// @brief Parse configurations from configuration string. + /// + /// @detail This configuration string has same syntax as configuration file contents. Make sure all the necessary + /// new line characters are provided. You may define '_STOP_ON_FIRSTELPP_ASSERTION' to make sure you + /// do not proceed without successful parse (This is recommended) + /// @param configurationsString + /// @param sender Sender configurations pointer. Usually 'this' is used from calling class + /// @param base Configurations to base new configuration repository off. This value is used when you want to use + /// existing Configurations to base all the values and then set rest of configuration via configuration text. + /// @return True if successfully parsed, false otherwise. + static bool parseFromText(const std::string& configurationsString, Configurations* sender, Configurations* base = nullptr) { + sender->setFromBase(base); + bool parsedSuccessfully = false; + std::stringstream ss(configurationsString); + std::string line = std::string(); + Level currLevel = Level::Unknown; + std::string currConfigStr = std::string(); + std::string currLevelStr = std::string(); + while (std::getline(ss, line)) { + parsedSuccessfully = parseLine(&line, &currConfigStr, &currLevelStr, &currLevel, sender); + ELPP_ASSERT(parsedSuccessfully, "Unable to parse configuration line: " << line); + } + return parsedSuccessfully; + } + + private: + friend class el::Loggers; + static void ignoreComments(std::string* line) { + std::size_t foundAt = 0; + std::size_t quotesStart = line->find("\""); + std::size_t quotesEnd = std::string::npos; + if (quotesStart != std::string::npos) { + quotesEnd = line->find("\"", quotesStart + 1); + while (quotesEnd != std::string::npos && line->at(quotesEnd - 1) == '\\') { + // Do not erase slash yet - we will erase it in parseLine(..) while loop + quotesEnd = line->find("\"", quotesEnd + 2); + } + } + if ((foundAt = line->find(base::consts::kConfigurationComment)) != std::string::npos) { + if (foundAt < quotesEnd) { + foundAt = line->find(base::consts::kConfigurationComment, quotesEnd + 1); + } + *line = line->substr(0, foundAt); + } + } + static inline bool isLevel(const std::string& line) { + return base::utils::Str::startsWith(line, std::string(base::consts::kConfigurationLevel)); + } + + static inline bool isComment(const std::string& line) { + return base::utils::Str::startsWith(line, std::string(base::consts::kConfigurationComment)); + } + + static inline bool isConfig(const std::string& line) { + std::size_t assignment = line.find('='); + return line != "" && + (line[0] >= 65 || line[0] <= 90 || line[0] >= 97 || line[0] <= 122) && + (assignment != std::string::npos) && + (line.size() > assignment); + } + + static bool parseLine(std::string* line, std::string* currConfigStr, std::string* currLevelStr, Level* currLevel, Configurations* conf) { + ConfigurationType currConfig = ConfigurationType::Unknown; + std::string currValue = std::string(); + *line = base::utils::Str::trim(*line); + if (isComment(*line)) return true; + ignoreComments(line); + *line = base::utils::Str::trim(*line); + if (line->empty()) { + // Comment ignored + return true; + } + if (isLevel(*line)) { + if (line->size() <= 2) { + return true; + } + *currLevelStr = line->substr(1, line->size() - 2); + *currLevelStr = base::utils::Str::toUpper(*currLevelStr); + *currLevelStr = base::utils::Str::trim(*currLevelStr); + *currLevel = LevelHelper::convertFromString(currLevelStr->c_str()); + return true; + } + if (isConfig(*line)) { + std::size_t assignment = line->find('='); + *currConfigStr = line->substr(0, assignment); + *currConfigStr = base::utils::Str::toUpper(*currConfigStr); + *currConfigStr = base::utils::Str::trim(*currConfigStr); + currConfig = ConfigurationTypeHelper::convertFromString(currConfigStr->c_str()); + currValue = line->substr(assignment + 1); + currValue = base::utils::Str::trim(currValue); + std::size_t quotesStart = currValue.find("\"", 0); + std::size_t quotesEnd = std::string::npos; + if (quotesStart != std::string::npos) { + quotesEnd = currValue.find("\"", quotesStart + 1); + while (quotesEnd != std::string::npos && currValue.at(quotesEnd - 1) == '\\') { + currValue = currValue.erase(quotesEnd - 1, 1); + quotesEnd = currValue.find("\"", quotesEnd + 2); + } + } + if (quotesStart != std::string::npos && quotesEnd != std::string::npos) { + // Quote provided - check and strip if valid + ELPP_ASSERT((quotesStart < quotesEnd), "Configuration error - No ending quote found in [" + << currConfigStr << "]"); + ELPP_ASSERT((quotesStart + 1 != quotesEnd), "Empty configuration value for [" << currConfigStr << "]"); + if ((quotesStart != quotesEnd) && (quotesStart + 1 != quotesEnd)) { + // Explicit check in case if assertion is disabled + currValue = currValue.substr(quotesStart + 1, quotesEnd - 1); + } + } + } + ELPP_ASSERT(*currLevel != Level::Unknown, "Unrecognized severity level [" << *currLevelStr << "]"); + ELPP_ASSERT(currConfig != ConfigurationType::Unknown, "Unrecognized configuration [" << *currConfigStr << "]"); + if (*currLevel == Level::Unknown || currConfig == ConfigurationType::Unknown) { + return false; // unrecognizable level or config + } + conf->set(*currLevel, currConfig, currValue); + return true; + } + }; + +private: + std::string m_configurationFile; + bool m_isFromFile; + friend class el::Loggers; + + /// @brief Unsafely sets configuration if does not already exist + void unsafeSetIfNotExist(Level level, ConfigurationType configurationType, const std::string& value) { + Configuration* conf = RegistryWithPred::get(level, configurationType); + if (conf == nullptr) { + unsafeSet(level, configurationType, value); + } + } + + /// @brief Thread unsafe set + void unsafeSet(Level level, ConfigurationType configurationType, const std::string& value) { + Configuration* conf = RegistryWithPred::get(level, configurationType); + if (conf == nullptr) { + registerNew(new Configuration(level, configurationType, value)); + } else { + conf->setValue(value); + } + if (level == Level::Global) { + unsafeSetGlobally(configurationType, value, false); + } + } + + /// @brief Sets configurations for all levels including Level::Global if includeGlobalLevel is true + /// @see Configurations::setGlobally(ConfigurationType configurationType, const std::string& value) + void setGlobally(ConfigurationType configurationType, const std::string& value, bool includeGlobalLevel) { + if (includeGlobalLevel) { + set(Level::Global, configurationType, value); + } + base::type::EnumType lIndex = LevelHelper::kMinValid; + LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { + set(LevelHelper::castFromInt(lIndex), configurationType, value); + return false; // Do not break lambda function yet as we need to set all levels regardless + }); + } + + /// @brief Sets configurations (Unsafely) for all levels including Level::Global if includeGlobalLevel is true + /// @see Configurations::setGlobally(ConfigurationType configurationType, const std::string& value) + void unsafeSetGlobally(ConfigurationType configurationType, const std::string& value, bool includeGlobalLevel) { + if (includeGlobalLevel) { + unsafeSet(Level::Global, configurationType, value); + } + base::type::EnumType lIndex = LevelHelper::kMinValid; + LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { + unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value); + return false; // Do not break lambda function yet as we need to set all levels regardless + }); + } +}; + +namespace base { +typedef std::shared_ptr FileStreamPtr; +typedef std::map LogStreamsReferenceMap; +/// @brief Configurations with data types. +/// +/// @detail el::Configurations have string based values. This is whats used internally in order to read correct configurations. +/// This is to perform faster while writing logs using correct configurations. +/// +/// This is thread safe and final class containing non-virtual destructor (means nothing should inherit this class) +class TypedConfigurations : public base::threading::ThreadSafe { +public: + /// @brief Constructor to initialize (construct) the object off el::Configurations + /// @param configurations Configurations pointer/reference to base this typed configurations off. + /// @param logStreamsReference Use ELPP->registeredLoggers()->logStreamsReference() + TypedConfigurations(Configurations* configurations, base::LogStreamsReferenceMap* logStreamsReference) { + m_configurations = configurations; + m_logStreamsReference = logStreamsReference; + build(m_configurations); + } + + TypedConfigurations(const TypedConfigurations& other) { + this->m_configurations = other.m_configurations; + this->m_logStreamsReference = other.m_logStreamsReference; + build(m_configurations); + } + + virtual ~TypedConfigurations(void) { + } + + const Configurations* configurations(void) const { + return m_configurations; + } + + inline bool enabled(Level level) { + return getConfigByVal(level, &m_enabledMap, "enabled"); + } + + inline bool toFile(Level level) { + return getConfigByVal(level, &m_toFileMap, "toFile"); + } + + inline const std::string& filename(Level level) { + return getConfigByRef(level, &m_filenameMap, "filename"); + } + + inline bool toStandardOutput(Level level) { + return getConfigByVal(level, &m_toStandardOutputMap, "toStandardOutput"); + } + + inline const base::LogFormat& logFormat(Level level) { + return getConfigByRef(level, &m_logFormatMap, "logFormat"); + } + + inline const base::MillisecondsWidth& millisecondsWidth(Level level = Level::Global) { + return getConfigByRef(level, &m_millisecondsWidthMap, "millisecondsWidth"); + } + + inline bool performanceTracking(Level level = Level::Global) { + return getConfigByVal(level, &m_performanceTrackingMap, "performanceTracking"); + } + + inline base::type::fstream_t* fileStream(Level level) { + return getConfigByRef(level, &m_fileStreamMap, "fileStream").get(); + } + + inline std::size_t maxLogFileSize(Level level) { + return getConfigByVal(level, &m_maxLogFileSizeMap, "maxLogFileSize"); + } + + inline std::size_t logFlushThreshold(Level level) { + return getConfigByVal(level, &m_logFlushThresholdMap, "logFlushThreshold"); + } + +private: + Configurations* m_configurations; + std::map m_enabledMap; + std::map m_toFileMap; + std::map m_filenameMap; + std::map m_toStandardOutputMap; + std::map m_logFormatMap; + std::map m_millisecondsWidthMap; + std::map m_performanceTrackingMap; + std::map m_fileStreamMap; + std::map m_maxLogFileSizeMap; + std::map m_logFlushThresholdMap; + base::LogStreamsReferenceMap* m_logStreamsReference; + + friend class el::Helpers; + friend class el::base::MessageBuilder; + friend class el::base::Writer; + friend class el::base::DefaultLogDispatchCallback; + friend class el::base::LogDispatcher; + + template + inline Conf_T getConfigByVal(Level level, const std::map* confMap, const char* confName) { + base::threading::ScopedLock scopedLock(lock()); + return unsafeGetConfigByVal(level, confMap, confName); // This is not unsafe anymore - mutex locked in scope + } + + template + inline Conf_T& getConfigByRef(Level level, std::map* confMap, const char* confName) { + base::threading::ScopedLock scopedLock(lock()); + return unsafeGetConfigByRef(level, confMap, confName); // This is not unsafe anymore - mutex locked in scope + } + + template + inline Conf_T unsafeGetConfigByVal(Level level, const std::map* confMap, const char* confName) { + ELPP_UNUSED(confName); + typename std::map::const_iterator it = confMap->find(level); + if (it == confMap->end()) { + try { + return confMap->at(Level::Global); + } catch (...) { + ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level [" + << LevelHelper::convertToString(level) << "]" + << std::endl << "Please ensure you have properly configured logger.", false); + return Conf_T(); + } + } + return it->second; + } + + template + inline Conf_T& unsafeGetConfigByRef(Level level, std::map* confMap, const char* confName) { + ELPP_UNUSED(confName); + typename std::map::iterator it = confMap->find(level); + if (it == confMap->end()) { + try { + return confMap->at(Level::Global); + } catch (...) { + ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level [" + << LevelHelper::convertToString(level) << "]" + << std::endl << "Please ensure you have properly configured logger.", false); + } + } + return it->second; + } + + template + void setValue(Level level, const Conf_T& value, std::map* confMap, bool includeGlobalLevel = true) { + // If map is empty and we are allowed to add into generic level (Level::Global), do it! + if (confMap->empty() && includeGlobalLevel) { + confMap->insert(std::make_pair(Level::Global, value)); + return; + } + // If same value exist in generic level already, dont add it to explicit level + typename std::map::iterator it = confMap->find(Level::Global); + if (it != confMap->end() && it->second == value) { + return; + } + // Now make sure we dont double up values if we really need to add it to explicit level + it = confMap->find(level); + if (it == confMap->end()) { + // Value not found for level, add new + confMap->insert(std::make_pair(level, value)); + } else { + // Value found, just update value + confMap->at(level) = value; + } + } + + void build(Configurations* configurations) { + base::threading::ScopedLock scopedLock(lock()); + auto getBool = [] (std::string boolStr) -> bool { // Pass by value for trimming + base::utils::Str::trim(boolStr); + return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1"); + }; + std::vector withFileSizeLimit; + for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) { + Configuration* conf = *it; + // We cannot use switch on strong enums because Intel C++ dont support them yet + if (conf->configurationType() == ConfigurationType::Enabled) { + setValue(conf->level(), getBool(conf->value()), &m_enabledMap); + } else if (conf->configurationType() == ConfigurationType::ToFile) { + setValue(conf->level(), getBool(conf->value()), &m_toFileMap); + } else if (conf->configurationType() == ConfigurationType::ToStandardOutput) { + setValue(conf->level(), getBool(conf->value()), &m_toStandardOutputMap); + } else if (conf->configurationType() == ConfigurationType::Filename) { + // We do not yet configure filename but we will configure in another + // loop. This is because if file cannot be created, we will force ToFile + // to be false. Because configuring logger is not necessarily performance + // sensative operation, we can live with another loop; (by the way this loop + // is not very heavy either) + } else if (conf->configurationType() == ConfigurationType::Format) { + setValue(conf->level(), base::LogFormat(conf->level(), + base::type::string_t(conf->value().begin(), conf->value().end())), &m_logFormatMap); + } else if (conf->configurationType() == ConfigurationType::MillisecondsWidth) { + setValue(Level::Global, + base::MillisecondsWidth(static_cast(getULong(conf->value()))), &m_millisecondsWidthMap); + } else if (conf->configurationType() == ConfigurationType::PerformanceTracking) { + setValue(Level::Global, getBool(conf->value()), &m_performanceTrackingMap); + } else if (conf->configurationType() == ConfigurationType::MaxLogFileSize) { + setValue(conf->level(), static_cast(getULong(conf->value())), &m_maxLogFileSizeMap); +#if !defined(ELPP_NO_DEFAULT_LOG_FILE) + withFileSizeLimit.push_back(conf); +#endif // !defined(ELPP_NO_DEFAULT_LOG_FILE) + } else if (conf->configurationType() == ConfigurationType::LogFlushThreshold) { + setValue(conf->level(), static_cast(getULong(conf->value())), &m_logFlushThresholdMap); + } + } + // As mentioned early, we will now set filename configuration in separate loop to deal with non-existent files + for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) { + Configuration* conf = *it; + if (conf->configurationType() == ConfigurationType::Filename) { + insertFile(conf->level(), conf->value()); + } + } + for (std::vector::iterator conf = withFileSizeLimit.begin(); + conf != withFileSizeLimit.end(); ++conf) { + // This is not unsafe as mutex is locked in currect scope + unsafeValidateFileRolling((*conf)->level(), base::defaultPreRollOutCallback); + } + } + + unsigned long getULong(std::string confVal) { + bool valid = true; + base::utils::Str::trim(confVal); + valid = !confVal.empty() && std::find_if(confVal.begin(), confVal.end(), + [](char c) { return !base::utils::Str::isDigit(c); }) == confVal.end(); + if (!valid) { + valid = false; + ELPP_ASSERT(valid, "Configuration value not a valid integer [" << confVal << "]"); + return 0; + } + return atol(confVal.c_str()); + } + + std::string resolveFilename(const std::string& filename) { + std::string resultingFilename = filename; + std::size_t dateIndex = std::string::npos; + std::string dateTimeFormatSpecifierStr = std::string(base::consts::kDateTimeFormatSpecifierForFilename); + if ((dateIndex = resultingFilename.find(dateTimeFormatSpecifierStr.c_str())) != std::string::npos) { + while (dateIndex > 0 && resultingFilename[dateIndex - 1] == base::consts::kFormatSpecifierChar) { + dateIndex = resultingFilename.find(dateTimeFormatSpecifierStr.c_str(), dateIndex + 1); + } + if (dateIndex != std::string::npos) { + const char* ptr = resultingFilename.c_str() + dateIndex; + // Goto end of specifier + ptr += dateTimeFormatSpecifierStr.size(); + std::string fmt; + if ((resultingFilename.size() > dateIndex) && (ptr[0] == '{')) { + // User has provided format for date/time + ++ptr; + int count = 1; // Start by 1 in order to remove starting brace + std::stringstream ss; + for (; *ptr; ++ptr, ++count) { + if (*ptr == '}') { + ++count; // In order to remove ending brace + break; + } + ss << *ptr; + } + resultingFilename.erase(dateIndex + dateTimeFormatSpecifierStr.size(), count); + fmt = ss.str(); + } else { + fmt = std::string(base::consts::kDefaultDateTimeFormatInFilename); + } + base::MillisecondsWidth msWidth(3); + std::string now = base::utils::DateTime::getDateTime(fmt.c_str(), &msWidth); + base::utils::Str::replaceAll(now, '/', '-'); // Replace path element since we are dealing with filename + base::utils::Str::replaceAll(resultingFilename, dateTimeFormatSpecifierStr, now); + } + } + return resultingFilename; + } + + void insertFile(Level level, const std::string& fullFilename) { + std::string resolvedFilename = resolveFilename(fullFilename); + if (resolvedFilename.empty()) { + std::cerr << "Could not load empty file for logging, please re-check your configurations for level [" + << LevelHelper::convertToString(level) << "]"; + } + std::string filePath = base::utils::File::extractPathFromFilename(resolvedFilename, base::consts::kFilePathSeperator); + if (filePath.size() < resolvedFilename.size()) { + base::utils::File::createPath(filePath); + } + auto create = [&](Level level) { + base::LogStreamsReferenceMap::iterator filestreamIter = m_logStreamsReference->find(resolvedFilename); + base::type::fstream_t* fs = nullptr; + if (filestreamIter == m_logStreamsReference->end()) { + // We need a completely new stream, nothing to share with + fs = base::utils::File::newFileStream(resolvedFilename); + m_filenameMap.insert(std::make_pair(level, resolvedFilename)); + m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(fs))); + m_logStreamsReference->insert(std::make_pair(resolvedFilename, base::FileStreamPtr(m_fileStreamMap.at(level)))); + } else { + // Woops! we have an existing one, share it! + m_filenameMap.insert(std::make_pair(level, filestreamIter->first)); + m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(filestreamIter->second))); + fs = filestreamIter->second.get(); + } + if (fs == nullptr) { + // We display bad file error from newFileStream() + ELPP_INTERNAL_ERROR("Setting [TO_FILE] of [" + << LevelHelper::convertToString(level) << "] to FALSE", false); + setValue(level, false, &m_toFileMap); + } + }; + // If we dont have file conf for any level, create it for Level::Global first + // otherwise create for specified level + create(m_filenameMap.empty() && m_fileStreamMap.empty() ? Level::Global : level); + } + + bool unsafeValidateFileRolling(Level level, const PreRollOutCallback& PreRollOutCallback) { + base::type::fstream_t* fs = unsafeGetConfigByRef(level, &m_fileStreamMap, "fileStream").get(); + if (fs == nullptr) { + return true; + } + std::size_t maxLogFileSize = unsafeGetConfigByVal(level, &m_maxLogFileSizeMap, "maxLogFileSize"); + std::size_t currFileSize = base::utils::File::getSizeOfFile(fs); + if (maxLogFileSize != 0 && currFileSize >= maxLogFileSize) { + std::string fname = unsafeGetConfigByRef(level, &m_filenameMap, "filename"); + ELPP_INTERNAL_INFO(1, "Truncating log file [" << fname << "] as a result of configurations for level [" + << LevelHelper::convertToString(level) << "]"); + fs->close(); + PreRollOutCallback(fname.c_str(), currFileSize); + fs->open(fname, std::fstream::out | std::fstream::trunc); + return true; + } + return false; + } + + bool validateFileRolling(Level level, const PreRollOutCallback& PreRollOutCallback) { + base::threading::ScopedLock scopedLock(lock()); + return unsafeValidateFileRolling(level, PreRollOutCallback); + } +}; +/// @brief Class that keeps record of current line hit for occasional logging +class HitCounter { +public: + HitCounter(void) : + m_filename(""), + m_lineNumber(0), + m_hitCounts(0) { + } + + HitCounter(const char* filename, unsigned long int lineNumber) : + m_filename(filename), + m_lineNumber(lineNumber), + m_hitCounts(0) { + } + + HitCounter(const HitCounter& hitCounter) : + m_filename(hitCounter.m_filename), + m_lineNumber(hitCounter.m_lineNumber), + m_hitCounts(hitCounter.m_hitCounts) { + } + + HitCounter& operator=(const HitCounter& hitCounter) { + m_filename = hitCounter.m_filename; + m_lineNumber = hitCounter.m_lineNumber; + m_hitCounts = hitCounter.m_hitCounts; + return *this; + } + + virtual ~HitCounter(void) { + } + + /// @brief Resets location of current hit counter + inline void resetLocation(const char* filename, unsigned long int lineNumber) { + m_filename = filename; + m_lineNumber = lineNumber; + } + + /// @brief Validates hit counts and resets it if necessary + inline void validateHitCounts(std::size_t n) { + if (m_hitCounts >= base::consts::kMaxLogPerCounter) { + m_hitCounts = (n >= 1 ? base::consts::kMaxLogPerCounter % n : 0); + } + ++m_hitCounts; + } + + inline const char* filename(void) const { + return m_filename; + } + + inline unsigned long int lineNumber(void) const { + return m_lineNumber; + } + + inline std::size_t hitCounts(void) const { + return m_hitCounts; + } + + inline void increment(void) { + ++m_hitCounts; + } + + class Predicate { + public: + Predicate(const char* filename, unsigned long int lineNumber) + : m_filename(filename), + m_lineNumber(lineNumber) { + } + inline bool operator()(const HitCounter* counter) { + return ((counter != nullptr) && + (strcmp(counter->m_filename, m_filename) == 0) && + (counter->m_lineNumber == m_lineNumber)); + } + + private: + const char* m_filename; + unsigned long int m_lineNumber; + }; + +private: + const char* m_filename; + unsigned long int m_lineNumber; + std::size_t m_hitCounts; +}; +/// @brief Repository for hit counters used across the application +class RegisteredHitCounters : public base::utils::RegistryWithPred { +public: + /// @brief Validates counter for every N, i.e, registers new if does not exist otherwise updates original one + /// @return True if validation resulted in triggering hit. Meaning logs should be written everytime true is returned + bool validateEveryN(const char* filename, unsigned long int lineNumber, std::size_t n) { + base::threading::ScopedLock scopedLock(lock()); + base::HitCounter* counter = get(filename, lineNumber); + if (counter == nullptr) { + registerNew(counter = new base::HitCounter(filename, lineNumber)); + } + counter->validateHitCounts(n); + bool result = (n >= 1 && counter->hitCounts() != 0 && counter->hitCounts() % n == 0); + return result; + } + + /// @brief Validates counter for hits >= N, i.e, registers new if does not exist otherwise updates original one + /// @return True if validation resulted in triggering hit. Meaning logs should be written everytime true is returned + bool validateAfterN(const char* filename, unsigned long int lineNumber, std::size_t n) { + base::threading::ScopedLock scopedLock(lock()); + base::HitCounter* counter = get(filename, lineNumber); + if (counter == nullptr) { + registerNew(counter = new base::HitCounter(filename, lineNumber)); + } + // Do not use validateHitCounts here since we do not want to reset counter here + // Note the >= instead of > because we are incrementing + // after this check + if (counter->hitCounts() >= n) + return true; + counter->increment(); + return false; + } + + /// @brief Validates counter for hits are <= n, i.e, registers new if does not exist otherwise updates original one + /// @return True if validation resulted in triggering hit. Meaning logs should be written everytime true is returned + bool validateNTimes(const char* filename, unsigned long int lineNumber, std::size_t n) { + base::threading::ScopedLock scopedLock(lock()); + base::HitCounter* counter = get(filename, lineNumber); + if (counter == nullptr) { + registerNew(counter = new base::HitCounter(filename, lineNumber)); + } + counter->increment(); + // Do not use validateHitCounts here since we do not want to reset counter here + if (counter->hitCounts() <= n) + return true; + return false; + } + + /// @brief Gets hit counter registered at specified position + inline const base::HitCounter* getCounter(const char* filename, unsigned long int lineNumber) { + base::threading::ScopedLock scopedLock(lock()); + return get(filename, lineNumber); + } +}; +/// @brief Action to be taken for dispatching +enum class DispatchAction : base::type::EnumType { + None = 1, NormalLog = 2, SysLog = 4 +}; +} // namespace base +template +class Callback : protected base::threading::ThreadSafe { +public: + Callback(void) : m_enabled(true) {} + inline bool enabled(void) const { return m_enabled; } + inline void setEnabled(bool enabled) { + base::threading::ScopedLock scopedLock(lock()); + m_enabled = enabled; + } +protected: + virtual void handle(const T* handlePtr) = 0; +private: + bool m_enabled; +}; +class LogDispatchData { +public: + LogDispatchData() : m_logMessage(nullptr), m_dispatchAction(base::DispatchAction::None) {} + inline const LogMessage* logMessage(void) const { return m_logMessage; } + inline base::DispatchAction dispatchAction(void) const { return m_dispatchAction; } +private: + LogMessage* m_logMessage; + base::DispatchAction m_dispatchAction; + friend class base::LogDispatcher; + + inline void setLogMessage(LogMessage* logMessage) { m_logMessage = logMessage; } + inline void setDispatchAction(base::DispatchAction dispatchAction) { m_dispatchAction = dispatchAction; } +}; +class LogDispatchCallback : public Callback { +private: + friend class base::LogDispatcher; +}; +class PerformanceTrackingCallback : public Callback { +private: + friend class base::PerformanceTracker; +}; +class LogBuilder : base::NoCopy { +public: + virtual ~LogBuilder(void) { ELPP_INTERNAL_INFO(3, "Destroying log builder...")} + virtual base::type::string_t build(const LogMessage* logMessage, bool appendNewLine) const = 0; + void convertToColoredOutput(base::type::string_t* logLine, Level level) { + if (!base::utils::s_termSupportsColor) return; + const base::type::char_t* resetColor = ELPP_LITERAL("\x1b[0m"); + if (level == Level::Error || level == Level::Fatal) + *logLine = ELPP_LITERAL("\x1b[31m") + *logLine + resetColor; + else if (level == Level::Warning) + *logLine = ELPP_LITERAL("\x1b[33m") + *logLine + resetColor; + } +private: + friend class el::base::DefaultLogDispatchCallback; +}; +typedef std::shared_ptr LogBuilderPtr; +/// @brief Represents a logger holding ID and configurations we need to write logs +/// +/// @detail This class does not write logs itself instead its used by writer to read configuations from. +class Logger : public base::threading::ThreadSafe, public Loggable { +public: + Logger(const std::string& id, base::LogStreamsReferenceMap* logStreamsReference) : + m_id(id), + m_typedConfigurations(nullptr), + m_parentApplicationName(std::string()), + m_isConfigured(false), + m_logStreamsReference(logStreamsReference) { + initUnflushedCount(); + } + + Logger(const std::string& id, const Configurations& configurations, base::LogStreamsReferenceMap* logStreamsReference) : + m_id(id), + m_typedConfigurations(nullptr), + m_parentApplicationName(std::string()), + m_isConfigured(false), + m_logStreamsReference(logStreamsReference) { + initUnflushedCount(); + configure(configurations); + } + + Logger(const Logger& logger) { + base::utils::safeDelete(m_typedConfigurations); + m_id = logger.m_id; + m_typedConfigurations = logger.m_typedConfigurations; + m_parentApplicationName = logger.m_parentApplicationName; + m_isConfigured = logger.m_isConfigured; + m_configurations = logger.m_configurations; + m_unflushedCount = logger.m_unflushedCount; + m_logStreamsReference = logger.m_logStreamsReference; + } + + Logger& operator=(const Logger& logger) { + base::utils::safeDelete(m_typedConfigurations); + m_id = logger.m_id; + m_typedConfigurations = logger.m_typedConfigurations; + m_parentApplicationName = logger.m_parentApplicationName; + m_isConfigured = logger.m_isConfigured; + m_configurations = logger.m_configurations; + m_unflushedCount = logger.m_unflushedCount; + m_logStreamsReference = logger.m_logStreamsReference; + return *this; + } + + virtual ~Logger(void) { + base::utils::safeDelete(m_typedConfigurations); + } + + virtual inline void log(el::base::type::ostream_t& os) const { + os << m_id.c_str(); + } + + /// @brief Configures the logger using specified configurations. + void configure(const Configurations& configurations) { + m_isConfigured = false; // we set it to false in case if we fail + initUnflushedCount(); + if (m_typedConfigurations != nullptr) { + Configurations* c = const_cast(m_typedConfigurations->configurations()); + if (c->hasConfiguration(Level::Global, ConfigurationType::Filename)) { + // This check is definitely needed for cases like ELPP_NO_DEFAULT_LOG_FILE + flush(); + } + } + base::threading::ScopedLock scopedLock(lock()); + if (m_configurations != configurations) { + m_configurations.setFromBase(const_cast(&configurations)); + } + base::utils::safeDelete(m_typedConfigurations); + m_typedConfigurations = new base::TypedConfigurations(&m_configurations, m_logStreamsReference); + resolveLoggerFormatSpec(); + m_isConfigured = true; + } + + /// @brief Reconfigures logger using existing configurations + inline void reconfigure(void) { + ELPP_INTERNAL_INFO(1, "Reconfiguring logger [" << m_id << "]"); + configure(m_configurations); + } + + inline const std::string& id(void) const { + return m_id; + } + + inline const std::string& parentApplicationName(void) const { + return m_parentApplicationName; + } + + inline void setParentApplicationName(const std::string& parentApplicationName) { + m_parentApplicationName = parentApplicationName; + } + + inline Configurations* configurations(void) { + return &m_configurations; + } + + inline base::TypedConfigurations* typedConfigurations(void) { + return m_typedConfigurations; + } + + static inline bool isValidId(const std::string& id) { + for (std::string::const_iterator it = id.begin(); it != id.end(); ++it) { + if (!base::utils::Str::contains(base::consts::kValidLoggerIdSymbols, *it)) { + return false; + } + } + return true; + } + /// @brief Flushes logger to sync all log files for all levels + inline void flush(void) { + ELPP_INTERNAL_INFO(3, "Flushing logger [" << m_id << "] all levels"); + base::threading::ScopedLock scopedLock(lock()); + base::type::EnumType lIndex = LevelHelper::kMinValid; + LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { + flush(LevelHelper::castFromInt(lIndex), nullptr); + return false; + }); + } + + inline void flush(Level level, base::type::fstream_t* fs) { + if (fs == nullptr && m_typedConfigurations->toFile(level)) { + fs = m_typedConfigurations->fileStream(level); + } + if (fs != nullptr) { + fs->flush(); + m_unflushedCount.find(level)->second = 0; + } + } + + inline bool isFlushNeeded(Level level) { + return ++m_unflushedCount.find(level)->second >= m_typedConfigurations->logFlushThreshold(level); + } + + inline LogBuilder* logBuilder(void) const { + return m_logBuilder.get(); + } + + inline void setLogBuilder(const LogBuilderPtr& logBuilder) { + m_logBuilder = logBuilder; + } + + inline bool enabled(Level level) const { + return m_typedConfigurations->enabled(level); + } + +#if ELPP_VARIADIC_TEMPLATES_SUPPORTED +# define LOGGER_LEVEL_WRITERS_SIGNATURES(FUNCTION_NAME)\ + template \ + inline void FUNCTION_NAME(const char*, const T&, const Args&...);\ + template \ + inline void FUNCTION_NAME(const T&); + + template + inline void verbose(int, const char*, const T&, const Args&...); + + template + inline void verbose(int, const T&); + + LOGGER_LEVEL_WRITERS_SIGNATURES(info) + LOGGER_LEVEL_WRITERS_SIGNATURES(debug) + LOGGER_LEVEL_WRITERS_SIGNATURES(warn) + LOGGER_LEVEL_WRITERS_SIGNATURES(error) + LOGGER_LEVEL_WRITERS_SIGNATURES(fatal) + LOGGER_LEVEL_WRITERS_SIGNATURES(trace) +# undef LOGGER_LEVEL_WRITERS_SIGNATURES +#endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED +private: + std::string m_id; + base::TypedConfigurations* m_typedConfigurations; + base::type::stringstream_t m_stream; + std::string m_parentApplicationName; + bool m_isConfigured; + Configurations m_configurations; + std::map m_unflushedCount; + base::LogStreamsReferenceMap* m_logStreamsReference; + LogBuilderPtr m_logBuilder; + + friend class el::LogMessage; + friend class el::Loggers; + friend class el::Helpers; + friend class el::base::RegisteredLoggers; + friend class el::base::DefaultLogDispatchCallback; + friend class el::base::MessageBuilder; + friend class el::base::Writer; + friend class el::base::PErrorWriter; + friend class el::base::Storage; + friend class el::base::PerformanceTracker; + friend class el::base::LogDispatcher; + + Logger(void); + +#if ELPP_VARIADIC_TEMPLATES_SUPPORTED + template + void log_(Level, int, const char*, const T&, const Args&...); + + template + inline void log_(Level, int, const T&); + + template + void log(Level, const char*, const T&, const Args&...); + + template + inline void log(Level, const T&); +#endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED + + void initUnflushedCount(void) { + m_unflushedCount.clear(); + base::type::EnumType lIndex = LevelHelper::kMinValid; + LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { + m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0)); + return false; + }); + } + + inline base::type::stringstream_t& stream(void) { + return m_stream; + } + + void resolveLoggerFormatSpec(void) const { + base::type::EnumType lIndex = LevelHelper::kMinValid; + LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { + base::LogFormat* logFormat = + const_cast(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex))); + base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id); + return false; + }); + } +}; +namespace base { +/// @brief Loggers repository +class RegisteredLoggers : public base::utils::Registry { +public: + explicit RegisteredLoggers(const LogBuilderPtr& defaultLogBuilder) : + m_defaultLogBuilder(defaultLogBuilder) { + m_defaultConfigurations.setToDefault(); + } + + virtual ~RegisteredLoggers(void) { + flushAll(); + } + + inline void setDefaultConfigurations(const Configurations& configurations) { + base::threading::ScopedLock scopedLock(lock()); + m_defaultConfigurations.setFromBase(const_cast(&configurations)); + } + + inline Configurations* defaultConfigurations(void) { + return &m_defaultConfigurations; + } + + Logger* get(const std::string& id, bool forceCreation = true) { + base::threading::ScopedLock scopedLock(lock()); + Logger* logger_ = base::utils::Registry::get(id); + if (logger_ == nullptr && forceCreation) { + bool validId = Logger::isValidId(id); + if (!validId) { + ELPP_ASSERT(validId, "Invalid logger ID [" << id << "]. Not registering this logger."); + return nullptr; + } + logger_ = new Logger(id, m_defaultConfigurations, &m_logStreamsReference); + logger_->m_logBuilder = m_defaultLogBuilder; + registerNew(id, logger_); + } + return logger_; + } + + bool remove(const std::string& id) { + if (id == "default") { + return false; + } + Logger* logger = base::utils::Registry::get(id); + if (logger != nullptr) { + unregister(logger); + } + return true; + } + + inline bool has(const std::string& id) { + return get(id, false) != nullptr; + } + + inline void unregister(Logger*& logger) { + base::threading::ScopedLock scopedLock(lock()); + base::utils::Registry::unregister(logger->id()); + } + + inline base::LogStreamsReferenceMap* logStreamsReference(void) { + return &m_logStreamsReference; + } + + inline void flushAll(void) { + ELPP_INTERNAL_INFO(1, "Flushing all log files"); + base::threading::ScopedLock scopedLock(lock()); + for (base::LogStreamsReferenceMap::iterator it = m_logStreamsReference.begin(); + it != m_logStreamsReference.end(); ++it) { + if (it->second.get() == nullptr) continue; + it->second->flush(); + } + } + +private: + LogBuilderPtr m_defaultLogBuilder; + Configurations m_defaultConfigurations; + base::LogStreamsReferenceMap m_logStreamsReference; + friend class el::base::Storage; +}; +/// @brief Represents registries for verbose logging +class VRegistry : base::NoCopy, public base::threading::ThreadSafe { +public: + explicit VRegistry(base::type::VerboseLevel level, base::type::EnumType* pFlags) : m_level(level), m_pFlags(pFlags) { + } + + /// @brief Sets verbose level. Accepted range is 0-9 + inline void setLevel(base::type::VerboseLevel level) { + base::threading::ScopedLock scopedLock(lock()); + if (level < 0) + m_level = 0; + else if (level > 9) + m_level = base::consts::kMaxVerboseLevel; + else + m_level = level; + } + + inline base::type::VerboseLevel level(void) const { + return m_level; + } + + inline void clearModules(void) { + base::threading::ScopedLock scopedLock(lock()); + m_modules.clear(); + } + + void setModules(const char* modules) { + base::threading::ScopedLock scopedLock(lock()); + auto addSuffix = [](std::stringstream& ss, const char* sfx, const char* prev) { + if (prev != nullptr && base::utils::Str::endsWith(ss.str(), std::string(prev))) { + std::string chr(ss.str().substr(0, ss.str().size() - strlen(prev))); + ss.str(std::string("")); + ss << chr; + } + if (base::utils::Str::endsWith(ss.str(), std::string(sfx))) { + std::string chr(ss.str().substr(0, ss.str().size() - strlen(sfx))); + ss.str(std::string("")); + ss << chr; + } + ss << sfx; + }; + auto insert = [&](std::stringstream& ss, base::type::VerboseLevel level) { + if (!base::utils::hasFlag(LoggingFlag::DisableVModulesExtensions, *m_pFlags)) { + addSuffix(ss, ".h", nullptr); + m_modules.insert(std::make_pair(ss.str(), level)); + addSuffix(ss, ".c", ".h"); + m_modules.insert(std::make_pair(ss.str(), level)); + addSuffix(ss, ".cpp", ".c"); + m_modules.insert(std::make_pair(ss.str(), level)); + addSuffix(ss, ".cc", ".cpp"); + m_modules.insert(std::make_pair(ss.str(), level)); + addSuffix(ss, ".cxx", ".cc"); + m_modules.insert(std::make_pair(ss.str(), level)); + addSuffix(ss, ".-inl.h", ".cxx"); + m_modules.insert(std::make_pair(ss.str(), level)); + addSuffix(ss, ".hxx", ".-inl.h"); + m_modules.insert(std::make_pair(ss.str(), level)); + addSuffix(ss, ".hpp", ".hxx"); + m_modules.insert(std::make_pair(ss.str(), level)); + addSuffix(ss, ".hh", ".hpp"); + } + m_modules.insert(std::make_pair(ss.str(), level)); + }; + bool isMod = true; + bool isLevel = false; + std::stringstream ss; + int level = -1; + for (; *modules; ++modules) { + switch (*modules) { + case '=': + isLevel = true; + isMod = false; + break; + case ',': + isLevel = false; + isMod = true; + if (!ss.str().empty() && level != -1) { + insert(ss, level); + ss.str(std::string("")); + level = -1; + } + break; + default: + if (isMod) { + ss << *modules; + } else if (isLevel) { + if (isdigit(*modules)) { + level = static_cast(*modules) - 48; + } + } + break; + } + } + if (!ss.str().empty() && level != -1) { + insert(ss, level); + } + } + + bool allowed(base::type::VerboseLevel vlevel, const char* file) { + base::threading::ScopedLock scopedLock(lock()); + if (m_modules.empty() || file == nullptr) { + return vlevel <= m_level; + } else { + std::map::iterator it = m_modules.begin(); + for (; it != m_modules.end(); ++it) { + if (base::utils::Str::wildCardMatch(file, it->first.c_str())) { + return vlevel <= it->second; + } + } + if (base::utils::hasFlag(LoggingFlag::AllowVerboseIfModuleNotSpecified, *m_pFlags)) { + return true; + } + return false; + } + } + + inline const std::map& modules(void) const { + return m_modules; + } + + void setFromArgs(const base::utils::CommandLineArgs* commandLineArgs) { + if (commandLineArgs->hasParam("-v") || commandLineArgs->hasParam("--verbose") || + commandLineArgs->hasParam("-V") || commandLineArgs->hasParam("--VERBOSE")) { + setLevel(base::consts::kMaxVerboseLevel); + } else if (commandLineArgs->hasParamWithValue("--v")) { + setLevel(atoi(commandLineArgs->getParamValue("--v"))); + } else if (commandLineArgs->hasParamWithValue("--V")) { + setLevel(atoi(commandLineArgs->getParamValue("--V"))); + } else if ((commandLineArgs->hasParamWithValue("-vmodule")) && vModulesEnabled()) { + setModules(commandLineArgs->getParamValue("-vmodule")); + } else if (commandLineArgs->hasParamWithValue("-VMODULE") && vModulesEnabled()) { + setModules(commandLineArgs->getParamValue("-VMODULE")); + } + } + + /// @brief Whether or not vModules enabled + inline bool vModulesEnabled(void) { + return !base::utils::hasFlag(LoggingFlag::DisableVModules, *m_pFlags); + } + +private: + base::type::VerboseLevel m_level; + base::type::EnumType* m_pFlags; + std::map m_modules; +}; +} // namespace base +class LogMessage { +public: + LogMessage(Level level, const std::string& file, unsigned long int line, const std::string& func, + base::type::VerboseLevel verboseLevel, Logger* logger) : + m_level(level), m_file(file), m_line(line), m_func(func), + m_verboseLevel(verboseLevel), m_logger(logger), m_message(std::move(logger->stream().str())) { + } + inline Level level(void) const { return m_level; } + inline const std::string& file(void) const { return m_file; } + inline unsigned long int line(void) const { return m_line; } // NOLINT + inline const std::string& func(void) const { return m_func; } + inline base::type::VerboseLevel verboseLevel(void) const { return m_verboseLevel; } + inline Logger* logger(void) const { return m_logger; } + inline const base::type::string_t& message(void) const { return m_message; } +private: + Level m_level; + std::string m_file; + unsigned long int m_line; + std::string m_func; + base::type::VerboseLevel m_verboseLevel; + Logger* m_logger; + base::type::string_t m_message; +}; +namespace base { +#if ELPP_ASYNC_LOGGING +class AsyncLogItem { +public: + explicit AsyncLogItem(const LogMessage& logMessage, const LogDispatchData& data, const base::type::string_t& logLine) + : m_logMessage(logMessage), m_dispatchData(data), m_logLine(logLine) {} + virtual ~AsyncLogItem() {} + inline LogMessage* logMessage(void) { return &m_logMessage; } + inline LogDispatchData* data(void) { return &m_dispatchData; } + inline base::type::string_t logLine(void) { return m_logLine; } +private: + LogMessage m_logMessage; + LogDispatchData m_dispatchData; + base::type::string_t m_logLine; +}; +class AsyncLogQueue : public base::threading::ThreadSafe { +public: + virtual ~AsyncLogQueue() { + ELPP_INTERNAL_INFO(6, "~AsyncLogQueue"); + } + + inline AsyncLogItem next(void) { + base::threading::ScopedLock scopedLock(lock()); + AsyncLogItem result = m_queue.front(); + m_queue.pop(); + return result; + } + + inline void push(const AsyncLogItem& item) { + base::threading::ScopedLock scopedLock(lock()); + m_queue.push(item); + } + inline void pop(void) { + base::threading::ScopedLock scopedLock(lock()); + m_queue.pop(); + } + inline AsyncLogItem front(void) { + base::threading::ScopedLock scopedLock(lock()); + return m_queue.front(); + } + inline bool empty(void) { + base::threading::ScopedLock scopedLock(lock()); + return m_queue.empty(); + } +private: + std::queue m_queue; +}; +class IWorker { +public: + virtual ~IWorker() {} + virtual void start() = 0; +}; +#endif // ELPP_ASYNC_LOGGING +/// @brief Easylogging++ management storage +class Storage : base::NoCopy, public base::threading::ThreadSafe { +public: +#if ELPP_ASYNC_LOGGING + Storage(const LogBuilderPtr& defaultLogBuilder, base::IWorker* asyncDispatchWorker) : +#else + explicit Storage(const LogBuilderPtr& defaultLogBuilder) : +#endif // ELPP_ASYNC_LOGGING + m_registeredHitCounters(new base::RegisteredHitCounters()), + m_registeredLoggers(new base::RegisteredLoggers(defaultLogBuilder)), + m_flags(0x0), + m_vRegistry(new base::VRegistry(0, &m_flags)), +#if ELPP_ASYNC_LOGGING + m_asyncLogQueue(new base::AsyncLogQueue()), + m_asyncDispatchWorker(asyncDispatchWorker), +#endif // ELPP_ASYNC_LOGGING + m_preRollOutCallback(base::defaultPreRollOutCallback) { + // Register default logger + m_registeredLoggers->get(std::string(base::consts::kDefaultLoggerId)); + // Register performance logger and reconfigure format + Logger* performanceLogger = m_registeredLoggers->get(std::string(base::consts::kPerformanceLoggerId)); + performanceLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%datetime %level %msg")); + performanceLogger->reconfigure(); +#if defined(ELPP_SYSLOG) + // Register syslog logger and reconfigure format + Logger* sysLogLogger = m_registeredLoggers->get(std::string(base::consts::kSysLogLoggerId)); + sysLogLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%level: %msg")); + sysLogLogger->reconfigure(); +#else + ELPP_UNUSED(base::consts::kSysLogLoggerId); +#endif // defined(ELPP_SYSLOG) + addFlag(LoggingFlag::AllowVerboseIfModuleNotSpecified); +#if ELPP_ASYNC_LOGGING + installLogDispatchCallback(std::string("AsyncLogDispatchCallback")); +#else + installLogDispatchCallback(std::string("DefaultLogDispatchCallback")); +#endif // ELPP_ASYNC_LOGGING + installPerformanceTrackingCallback(std::string("DefaultPerformanceTrackingCallback")); + ELPP_INTERNAL_INFO(1, "Easylogging++ has been initialized"); +#if ELPP_ASYNC_LOGGING + m_asyncDispatchWorker->start(); +#endif // ELPP_ASYNC_LOGGING + } + + virtual ~Storage(void) { + ELPP_INTERNAL_INFO(4, "Destroying storage"); +#if ELPP_ASYNC_LOGGING + ELPP_INTERNAL_INFO(5, "Replacing log dispatch callback to synchronous"); + uninstallLogDispatchCallback(std::string("AsyncLogDispatchCallback")); + installLogDispatchCallback(std::string("DefaultLogDispatchCallback")); + ELPP_INTERNAL_INFO(5, "Destroying asyncDispatchWorker"); + base::utils::safeDelete(m_asyncDispatchWorker); + ELPP_INTERNAL_INFO(5, "Destroying asyncLogQueue"); + base::utils::safeDelete(m_asyncLogQueue); +#endif // ELPP_ASYNC_LOGGING + ELPP_INTERNAL_INFO(5, "Destroying registeredHitCounters"); + base::utils::safeDelete(m_registeredHitCounters); + ELPP_INTERNAL_INFO(5, "Destroying registeredLoggers"); + base::utils::safeDelete(m_registeredLoggers); + ELPP_INTERNAL_INFO(5, "Destroying vRegistry"); + base::utils::safeDelete(m_vRegistry); + } + + inline bool validateEveryNCounter(const char* filename, unsigned long int lineNumber, std::size_t occasion) { + return hitCounters()->validateEveryN(filename, lineNumber, occasion); + } + + inline bool validateAfterNCounter(const char* filename, unsigned long int lineNumber, std::size_t n) { // NOLINT + return hitCounters()->validateAfterN(filename, lineNumber, n); + } + + inline bool validateNTimesCounter(const char* filename, unsigned long int lineNumber, std::size_t n) { // NOLINT + return hitCounters()->validateNTimes(filename, lineNumber, n); + } + + inline base::RegisteredHitCounters* hitCounters(void) const { + return m_registeredHitCounters; + } + + inline base::RegisteredLoggers* registeredLoggers(void) const { + return m_registeredLoggers; + } + + inline base::VRegistry* vRegistry(void) const { + return m_vRegistry; + } + +#if ELPP_ASYNC_LOGGING + inline base::AsyncLogQueue* asyncLogQueue(void) const { + return m_asyncLogQueue; + } +#endif // ELPP_ASYNC_LOGGING + + inline const base::utils::CommandLineArgs* commandLineArgs(void) const { + return &m_commandLineArgs; + } + + inline void addFlag(LoggingFlag flag) { + base::utils::addFlag(flag, &m_flags); + } + + inline void removeFlag(LoggingFlag flag) { + base::utils::removeFlag(flag, &m_flags); + } + + inline bool hasFlag(LoggingFlag flag) const { + return base::utils::hasFlag(flag, m_flags); + } + + inline base::type::EnumType flags(void) const { + return m_flags; + } + + inline void setFlags(base::type::EnumType flags) { + m_flags = flags; + } + + inline void setPreRollOutCallback(const PreRollOutCallback& callback) { + m_preRollOutCallback = callback; + } + + inline void unsetPreRollOutCallback(void) { + m_preRollOutCallback = base::defaultPreRollOutCallback; + } + + inline PreRollOutCallback& preRollOutCallback(void) { + return m_preRollOutCallback; + } + + inline bool hasCustomFormatSpecifier(const char* formatSpecifier) { + base::threading::ScopedLock scopedLock(lock()); + return std::find(m_customFormatSpecifiers.begin(), m_customFormatSpecifiers.end(), + formatSpecifier) != m_customFormatSpecifiers.end(); + } + + inline void installCustomFormatSpecifier(const CustomFormatSpecifier& customFormatSpecifier) { + if (hasCustomFormatSpecifier(customFormatSpecifier.formatSpecifier())) { + return; + } + base::threading::ScopedLock scopedLock(lock()); + m_customFormatSpecifiers.push_back(customFormatSpecifier); + } + + inline bool uninstallCustomFormatSpecifier(const char* formatSpecifier) { + base::threading::ScopedLock scopedLock(lock()); + std::vector::iterator it = std::find(m_customFormatSpecifiers.begin(), + m_customFormatSpecifiers.end(), formatSpecifier); + if (it != m_customFormatSpecifiers.end() && strcmp(formatSpecifier, it->formatSpecifier()) == 0) { + m_customFormatSpecifiers.erase(it); + return true; + } + return false; + } + + const std::vector* customFormatSpecifiers(void) const { + return &m_customFormatSpecifiers; + } + + inline void setLoggingLevel(Level level) { + m_loggingLevel = level; + } + + template + inline bool installLogDispatchCallback(const std::string& id) { + return installCallback(id, &m_logDispatchCallbacks); + } + + template + inline void uninstallLogDispatchCallback(const std::string& id) { + uninstallCallback(id, &m_logDispatchCallbacks); + } + template + inline T* logDispatchCallback(const std::string& id) { + return callback(id, &m_logDispatchCallbacks); + } + + template + inline bool installPerformanceTrackingCallback(const std::string& id) { + return installCallback(id, &m_performanceTrackingCallbacks); + } + + template + inline void uninstallPerformanceTrackingCallback(const std::string& id) { + uninstallCallback(id, &m_performanceTrackingCallbacks); + } + + template + inline T* performanceTrackingCallback(const std::string& id) { + return callback(id, &m_performanceTrackingCallbacks); + } +private: + base::RegisteredHitCounters* m_registeredHitCounters; + base::RegisteredLoggers* m_registeredLoggers; + base::type::EnumType m_flags; + base::VRegistry* m_vRegistry; +#if ELPP_ASYNC_LOGGING + base::AsyncLogQueue* m_asyncLogQueue; + base::IWorker* m_asyncDispatchWorker; +#endif // ELPP_ASYNC_LOGGING + base::utils::CommandLineArgs m_commandLineArgs; + PreRollOutCallback m_preRollOutCallback; + std::map m_logDispatchCallbacks; + std::map m_performanceTrackingCallbacks; + std::vector m_customFormatSpecifiers; + Level m_loggingLevel; + + friend class el::Helpers; + friend class el::base::DefaultLogDispatchCallback; + friend class el::LogBuilder; + friend class el::base::MessageBuilder; + friend class el::base::Writer; + friend class el::base::PerformanceTracker; + friend class el::base::LogDispatcher; + + void setApplicationArguments(int argc, char** argv) { + m_commandLineArgs.setArgs(argc, argv); + m_vRegistry->setFromArgs(commandLineArgs()); + // default log file +#if !defined(ELPP_DISABLE_LOG_FILE_FROM_ARG) + if (m_commandLineArgs.hasParamWithValue(base::consts::kDefaultLogFileParam)) { + Configurations c; + c.setGlobally(ConfigurationType::Filename, std::string(m_commandLineArgs.getParamValue(base::consts::kDefaultLogFileParam))); + registeredLoggers()->setDefaultConfigurations(c); + for (base::RegisteredLoggers::iterator it = registeredLoggers()->begin(); + it != registeredLoggers()->end(); ++it) { + it->second->configure(c); + } + } +#endif // !defined(ELPP_DISABLE_LOG_FILE_FROM_ARG) +#if defined(ELPP_LOGGING_FLAGS_FROM_ARG) + if (m_commandLineArgs.hasParamWithValue(base::consts::kLoggingFlagsParam)) { + m_flags = atoi(m_commandLineArgs.getParamValue(base::consts::kLoggingFlagsParam)); + } +#endif // defined(ELPP_LOGGING_FLAGS_FROM_ARG) + } + + inline void setApplicationArguments(int argc, const char** argv) { + setApplicationArguments(argc, const_cast(argv)); + } + + template + inline bool installCallback(const std::string& id, std::map* mapT) { + if (mapT->find(id) == mapT->end()) { + mapT->insert(std::make_pair(id, TPtr(new T()))); + return true; + } + return false; + } + + template + inline void uninstallCallback(const std::string& id, std::map* mapT) { + if (mapT->find(id) != mapT->end()) { + mapT->erase(id); + } + } + + template + inline T* callback(const std::string& id, std::map* mapT) { + typename std::map::iterator iter = mapT->find(id); + if (iter != mapT->end()) { + return static_cast(iter->second.get()); + } + return nullptr; + } +}; +extern ELPP_EXPORT base::type::StoragePointer elStorage; +#define ELPP el::base::elStorage +class DefaultLogDispatchCallback : public LogDispatchCallback { +protected: + void handle(const LogDispatchData* data) { + m_data = data; + dispatch(std::move(m_data->logMessage()->logger()->logBuilder()->build(m_data->logMessage(), + m_data->dispatchAction() == base::DispatchAction::NormalLog))); + } +private: + const LogDispatchData* m_data; + void dispatch(base::type::string_t&& logLine) { + if (m_data->dispatchAction() == base::DispatchAction::NormalLog) { + if (m_data->logMessage()->logger()->m_typedConfigurations->toFile(m_data->logMessage()->level())) { + base::type::fstream_t* fs = m_data->logMessage()->logger()->m_typedConfigurations->fileStream(m_data->logMessage()->level()); + if (fs != nullptr) { + fs->write(logLine.c_str(), logLine.size()); + if (fs->fail()) { + ELPP_INTERNAL_ERROR("Unable to write log to file [" + << m_data->logMessage()->logger()->m_typedConfigurations->filename(m_data->logMessage()->level()) << "].\n" + << "Few possible reasons (could be something else):\n" << " * Permission denied\n" + << " * Disk full\n" << " * Disk is not writable", true); + } else { + if (ELPP->hasFlag(LoggingFlag::ImmediateFlush) || (m_data->logMessage()->logger()->isFlushNeeded(m_data->logMessage()->level()))) { + m_data->logMessage()->logger()->flush(m_data->logMessage()->level(), fs); + } + } + } else { + ELPP_INTERNAL_ERROR("Log file for [" << LevelHelper::convertToString(m_data->logMessage()->level()) << "] " + << "has not been configured but [TO_FILE] is configured to TRUE. [Logger ID: " + << m_data->logMessage()->logger()->id() << "]", false); + } + } + if (m_data->logMessage()->logger()->m_typedConfigurations->toStandardOutput(m_data->logMessage()->level())) { + if (ELPP->hasFlag(LoggingFlag::ColoredTerminalOutput)) + m_data->logMessage()->logger()->logBuilder()->convertToColoredOutput(&logLine, m_data->logMessage()->level()); + ELPP_COUT << ELPP_COUT_LINE(logLine); + } + } +#if defined(ELPP_SYSLOG) + else if (m_data->dispatchAction() == base::DispatchAction::SysLog) { + // Determine syslog priority + int sysLogPriority = 0; + if (m_data->logMessage()->level() == Level::Fatal) + sysLogPriority = LOG_EMERG; + else if (m_data->logMessage()->level() == Level::Error) + sysLogPriority = LOG_ERR; + else if (m_data->logMessage()->level() == Level::Warning) + sysLogPriority = LOG_WARNING; + else if (m_data->logMessage()->level() == Level::Info) + sysLogPriority = LOG_INFO; + else if (m_data->logMessage()->level() == Level::Debug) + sysLogPriority = LOG_DEBUG; + else + sysLogPriority = LOG_NOTICE; +# if defined(ELPP_UNICODE) + char* line = base::utils::Str::wcharPtrToCharPtr(logLine.c_str()); + syslog(sysLogPriority, "%s", line); + free(line); +# else + syslog(sysLogPriority, "%s", logLine.c_str()); +# endif + } +#endif // defined(ELPP_SYSLOG) + } +}; +#if ELPP_ASYNC_LOGGING +class AsyncLogDispatchCallback : public LogDispatchCallback { +protected: + void handle(const LogDispatchData* data) { + base::type::string_t logLine = data->logMessage()->logger()->logBuilder()->build(data->logMessage(), data->dispatchAction() == base::DispatchAction::NormalLog); + if (data->dispatchAction() == base::DispatchAction::NormalLog && data->logMessage()->logger()->typedConfigurations()->toStandardOutput(data->logMessage()->level())) { + if (ELPP->hasFlag(LoggingFlag::ColoredTerminalOutput)) + data->logMessage()->logger()->logBuilder()->convertToColoredOutput(&logLine, data->logMessage()->level()); + ELPP_COUT << ELPP_COUT_LINE(logLine); + } + // Save resources and only queue if we want to write to file otherwise just ignore handler + if (data->logMessage()->logger()->typedConfigurations()->toFile(data->logMessage()->level())) { + ELPP->asyncLogQueue()->push(AsyncLogItem(*(data->logMessage()), *data, logLine)); + } + } +}; +class AsyncDispatchWorker : public base::IWorker, public base::threading::ThreadSafe { +public: + AsyncDispatchWorker() { + setContinueRunning(false); + } + + virtual ~AsyncDispatchWorker() { + setContinueRunning(false); + ELPP_INTERNAL_INFO(6, "Stopping dispatch worker - Cleaning log queue"); + clean(); + ELPP_INTERNAL_INFO(6, "Log queue cleaned"); + } + + inline bool clean() { + std::mutex m; + std::unique_lock lk(m); + cv.wait(lk, []{ return !ELPP->asyncLogQueue()->empty(); }); + emptyQueue(); + lk.unlock(); + cv.notify_one(); + return ELPP->asyncLogQueue()->empty(); + } + + inline void emptyQueue() { + while (!ELPP->asyncLogQueue()->empty()) { + AsyncLogItem data = ELPP->asyncLogQueue()->next(); + handle(&data); + base::threading::msleep(100); + } + } + + virtual inline void start() { + base::threading::msleep(5000); // Wait extra few seconds + setContinueRunning(true); + std::thread t1(&AsyncDispatchWorker::runner, this); + t1.join(); + } + + void handle(AsyncLogItem* logItem) { + LogDispatchData* data = logItem->data(); + LogMessage* logMessage = logItem->logMessage(); + Logger* logger = logMessage->logger(); + base::TypedConfigurations* conf = logger->typedConfigurations(); + base::type::string_t logLine = logItem->logLine(); + if (data->dispatchAction() == base::DispatchAction::NormalLog) { + if (conf->toFile(logMessage->level())) { + base::type::fstream_t* fs = conf->fileStream(logMessage->level()); + if (fs != nullptr) { + fs->write(logLine.c_str(), logLine.size()); + if (fs->fail()) { + ELPP_INTERNAL_ERROR("Unable to write log to file [" + << conf->filename(logMessage->level()) << "].\n" + << "Few possible reasons (could be something else):\n" << " * Permission denied\n" + << " * Disk full\n" << " * Disk is not writable", true); + } else { + if (ELPP->hasFlag(LoggingFlag::ImmediateFlush) || (logger->isFlushNeeded(logMessage->level()))) { + logger->flush(logMessage->level(), fs); + } + } + } else { + ELPP_INTERNAL_ERROR("Log file for [" << LevelHelper::convertToString(logMessage->level()) << "] " + << "has not been configured but [TO_FILE] is configured to TRUE. [Logger ID: " << logger->id() << "]", false); + } + } + } +# if defined(ELPP_SYSLOG) + else if (data->dispatchAction() == base::DispatchAction::SysLog) { + // Determine syslog priority + int sysLogPriority = 0; + if (logMessage->level() == Level::Fatal) + sysLogPriority = LOG_EMERG; + else if (logMessage->level() == Level::Error) + sysLogPriority = LOG_ERR; + else if (logMessage->level() == Level::Warning) + sysLogPriority = LOG_WARNING; + else if (logMessage->level() == Level::Info) + sysLogPriority = LOG_INFO; + else if (logMessage->level() == Level::Debug) + sysLogPriority = LOG_DEBUG; + else + sysLogPriority = LOG_NOTICE; +# if defined(ELPP_UNICODE) + char* line = base::utils::Str::wcharPtrToCharPtr(logLine.c_str()); + syslog(sysLogPriority, "%s", line); + free(line); +# else + syslog(sysLogPriority, "%s", logLine.c_str()); +# endif + } +# endif // defined(ELPP_SYSLOG) + } + + void run() { + while (continueRunning()) { + emptyQueue(); + base::threading::msleep(10); // 10ms + } + } + + static void* runner(void *context) { + static_cast(context)->run(); + return NULL; + } + + void setContinueRunning(bool value) { + base::threading::ScopedLock scopedLock(m_continueRunningMutex); + m_continueRunning = value; + } + bool continueRunning(void) { + return m_continueRunning; + } +private: + std::condition_variable cv; + bool m_continueRunning; + base::threading::Mutex m_continueRunningMutex; +}; +#endif // ELPP_ASYNC_LOGGING +} // namespace base +namespace base { +class DefaultLogBuilder : public LogBuilder { +public: + base::type::string_t build(const LogMessage* logMessage, bool appendNewLine) const { + base::TypedConfigurations* tc = logMessage->logger()->typedConfigurations(); + const base::LogFormat* logFormat = &tc->logFormat(logMessage->level()); + base::type::string_t logLine = logFormat->format(); + char buff[base::consts::kSourceFilenameMaxLength + base::consts::kSourceLineMaxLength] = ""; + const char* bufLim = buff + sizeof(buff); + if (logFormat->hasFlag(base::FormatFlags::AppName)) { + // App name + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kAppNameFormatSpecifier, + logMessage->logger()->parentApplicationName()); + } + if (logFormat->hasFlag(base::FormatFlags::ThreadId)) { + // Thread ID + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kThreadIdFormatSpecifier, + base::threading::getCurrentThreadId()); + } + if (logFormat->hasFlag(base::FormatFlags::DateTime)) { + // DateTime + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kDateTimeFormatSpecifier, + base::utils::DateTime::getDateTime(logFormat->dateTimeFormat().c_str(), + &tc->millisecondsWidth(logMessage->level()))); + } + if (logFormat->hasFlag(base::FormatFlags::Function)) { + // Function + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogFunctionFormatSpecifier, logMessage->func()); + } + if (logFormat->hasFlag(base::FormatFlags::File)) { + // File + char* buf = base::utils::Str::clearBuff(buff, base::consts::kSourceFilenameMaxLength); + base::utils::File::buildStrippedFilename(logMessage->file().c_str(), buff); + buf = base::utils::Str::addToBuff(buff, buf, bufLim); + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogFileFormatSpecifier, std::string(buff)); + } + if (logFormat->hasFlag(base::FormatFlags::FileBase)) { + // FileBase + char* buf = base::utils::Str::clearBuff(buff, base::consts::kSourceFilenameMaxLength); + base::utils::File::buildBaseFilename(logMessage->file(), buff); + buf = base::utils::Str::addToBuff(buff, buf, bufLim); + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogFileBaseFormatSpecifier, std::string(buff)); + } + if (logFormat->hasFlag(base::FormatFlags::Line)) { + // Line + char* buf = base::utils::Str::clearBuff(buff, base::consts::kSourceLineMaxLength); + buf = base::utils::Str::convertAndAddToBuff(logMessage->line(), + base::consts::kSourceLineMaxLength, buf, bufLim, false); + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogLineFormatSpecifier, std::string(buff)); + } + if (logFormat->hasFlag(base::FormatFlags::Location)) { + // Location + char* buf = base::utils::Str::clearBuff(buff, + base::consts::kSourceFilenameMaxLength + base::consts::kSourceLineMaxLength); + base::utils::File::buildStrippedFilename(logMessage->file().c_str(), buff); + buf = base::utils::Str::addToBuff(buff, buf, bufLim); + buf = base::utils::Str::addToBuff(":", buf, bufLim); + buf = base::utils::Str::convertAndAddToBuff(logMessage->line(), + base::consts::kSourceLineMaxLength, buf, bufLim, false); + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogLocationFormatSpecifier, std::string(buff)); + } + if (logMessage->level() == Level::Verbose && logFormat->hasFlag(base::FormatFlags::VerboseLevel)) { + // Verbose level + char* buf = base::utils::Str::clearBuff(buff, 1); + buf = base::utils::Str::convertAndAddToBuff(logMessage->verboseLevel(), 1, buf, bufLim, false); + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kVerboseLevelFormatSpecifier, std::string(buff)); + } + if (logFormat->hasFlag(base::FormatFlags::LogMessage)) { + // Log message + base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kMessageFormatSpecifier, logMessage->message()); + } +#if !defined(ELPP_DISABLE_CUSTOM_FORMAT_SPECIFIERS) + for (std::vector::const_iterator it = ELPP->customFormatSpecifiers()->begin(); + it != ELPP->customFormatSpecifiers()->end(); ++it) { + std::string fs(it->formatSpecifier()); + base::type::string_t wcsFormatSpecifier(fs.begin(), fs.end()); + base::utils::Str::replaceFirstWithEscape(logLine, wcsFormatSpecifier, std::string(it->resolver()())); + } +#endif // !defined(ELPP_DISABLE_CUSTOM_FORMAT_SPECIFIERS) + if (appendNewLine) logLine += ELPP_LITERAL("\n"); + return logLine; + } +}; +/// @brief Dispatches log messages +class LogDispatcher : base::NoCopy { +public: + LogDispatcher(bool proceed, LogMessage&& logMessage, base::DispatchAction dispatchAction) : + m_proceed(proceed), + m_logMessage(std::move(logMessage)), + m_dispatchAction(std::move(dispatchAction)) { + } + + void dispatch(void) { + if (m_proceed && m_dispatchAction == base::DispatchAction::None) { + m_proceed = false; + } + if (!m_proceed) { + return; + } + // We minimize the time of ELPP's lock - this lock is released after log is written + base::threading::ScopedLock scopedLock(ELPP->lock()); + base::TypedConfigurations* tc = m_logMessage.logger()->m_typedConfigurations; + if (ELPP->hasFlag(LoggingFlag::StrictLogFileSizeCheck)) { + tc->validateFileRolling(m_logMessage.level(), ELPP->preRollOutCallback()); + } + LogDispatchCallback* callback = nullptr; + LogDispatchData data; + for (const std::pair& h + : ELPP->m_logDispatchCallbacks) { + callback = h.second.get(); + if (callback != nullptr && callback->enabled()) { + data.setLogMessage(&m_logMessage); + data.setDispatchAction(m_dispatchAction); + callback->acquireLock(); + callback->handle(&data); + callback->releaseLock(); + } + } + } + +private: + bool m_proceed; + LogMessage m_logMessage; + base::DispatchAction m_dispatchAction; +}; +#if defined(ELPP_STL_LOGGING) +/// @brief Workarounds to write some STL logs +/// +/// @detail There is workaround needed to loop through some stl containers. In order to do that, we need iterable containers +/// of same type and provide iterator interface and pass it on to writeIterator(). +/// Remember, this is passed by value in constructor so that we dont change original containers. +/// This operation is as expensive as Big-O(std::min(class_.size(), base::consts::kMaxLogPerContainer)) +namespace workarounds { +/// @brief Abstract IterableContainer template that provides interface for iterable classes of type T +template +class IterableContainer { +public: + typedef typename Container::iterator iterator; + typedef typename Container::const_iterator const_iterator; + IterableContainer(void) {} + virtual ~IterableContainer(void) {} + iterator begin(void) { return getContainer().begin(); } + iterator end(void) { return getContainer().end(); } +private: + virtual Container& getContainer(void) = 0; +}; +/// @brief Implements IterableContainer and provides iterable std::priority_queue class +template, typename Comparator = std::less> +class IterablePriorityQueue : public IterableContainer, public std::priority_queue { +public: + IterablePriorityQueue(std::priority_queue queue_) { + std::size_t count_ = 0; + while (++count_ < base::consts::kMaxLogPerContainer && !queue_.empty()) { + this->push(queue_.top()); + queue_.pop(); + } + } +private: + inline Container& getContainer(void) { + return this->c; + } +}; +/// @brief Implements IterableContainer and provides iterable std::queue class +template> +class IterableQueue : public IterableContainer, public std::queue { +public: + IterableQueue(std::queue queue_) { + std::size_t count_ = 0; + while (++count_ < base::consts::kMaxLogPerContainer && !queue_.empty()) { + this->push(queue_.front()); + queue_.pop(); + } + } +private: + inline Container& getContainer(void) { + return this->c; + } +}; +/// @brief Implements IterableContainer and provides iterable std::stack class +template> +class IterableStack : public IterableContainer, public std::stack { +public: + IterableStack(std::stack stack_) { + std::size_t count_ = 0; + while (++count_ < base::consts::kMaxLogPerContainer && !stack_.empty()) { + this->push(stack_.top()); + stack_.pop(); + } + } +private: + inline Container& getContainer(void) { + return this->c; + } +}; +} // namespace workarounds +#endif // defined(ELPP_STL_LOGGING) +// Log message builder +class MessageBuilder { +public: + MessageBuilder(void) : m_logger(nullptr), m_containerLogSeperator(ELPP_LITERAL("")) {} + void initialize(Logger* logger) { + m_logger = logger; + m_containerLogSeperator = ELPP->hasFlag(LoggingFlag::NewLineForContainer) ? + ELPP_LITERAL("\n ") : ELPP_LITERAL(", "); + } + +# define ELPP_SIMPLE_LOG(LOG_TYPE)\ + inline MessageBuilder& operator<<(LOG_TYPE msg) {\ + m_logger->stream() << msg;\ + if (ELPP->hasFlag(LoggingFlag::AutoSpacing)) {\ + m_logger->stream() << " ";\ + }\ + return *this;\ + } + + inline MessageBuilder& operator<<(const std::string& msg) { + return operator<<(msg.c_str()); + } + ELPP_SIMPLE_LOG(char) + ELPP_SIMPLE_LOG(bool) + ELPP_SIMPLE_LOG(signed short) + ELPP_SIMPLE_LOG(unsigned short) + ELPP_SIMPLE_LOG(signed int) + ELPP_SIMPLE_LOG(unsigned int) + ELPP_SIMPLE_LOG(signed long) + ELPP_SIMPLE_LOG(unsigned long) + ELPP_SIMPLE_LOG(float) + ELPP_SIMPLE_LOG(double) + ELPP_SIMPLE_LOG(char*) + ELPP_SIMPLE_LOG(const char*) + ELPP_SIMPLE_LOG(const void*) + ELPP_SIMPLE_LOG(long double) + inline MessageBuilder& operator<<(const std::wstring& msg) { + return operator<<(msg.c_str()); + } + inline MessageBuilder& operator<<(const wchar_t* msg) { + if (msg == nullptr) { + m_logger->stream() << base::consts::kNullPointer; + return *this; + } +# if defined(ELPP_UNICODE) + m_logger->stream() << msg; +# else + char* buff_ = base::utils::Str::wcharPtrToCharPtr(msg); + m_logger->stream() << buff_; + free(buff_); +# endif + if (ELPP->hasFlag(LoggingFlag::AutoSpacing)) { + m_logger->stream() << " "; + } + return *this; + } + // ostream manipulators + inline MessageBuilder& operator<<(std::ostream& (*OStreamMani)(std::ostream&)) { + m_logger->stream() << OStreamMani; + return *this; + } +#define ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(temp) \ + template \ + inline MessageBuilder& operator<<(const temp& template_inst) { \ + return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ + } +#define ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(temp) \ + template \ + inline MessageBuilder& operator<<(const temp& template_inst) { \ + return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ + } +#define ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(temp) \ + template \ + inline MessageBuilder& operator<<(const temp& template_inst) { \ + return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ + } +#define ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(temp) \ + template \ + inline MessageBuilder& operator<<(const temp& template_inst) { \ + return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ + } +#define ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG(temp) \ + template \ + inline MessageBuilder& operator<<(const temp& template_inst) { \ + return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ + } + +#if defined(ELPP_STL_LOGGING) + ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(std::vector) + ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(std::list) + ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(std::deque) + ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(std::set) + ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(std::multiset) + ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(std::map) + ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(std::multimap) + template + inline MessageBuilder& operator<<(const std::queue& queue_) { + base::workarounds::IterableQueue iterableQueue_ = + static_cast >(queue_); + return writeIterator(iterableQueue_.begin(), iterableQueue_.end(), iterableQueue_.size()); + } + template + inline MessageBuilder& operator<<(const std::stack& stack_) { + base::workarounds::IterableStack iterableStack_ = + static_cast >(stack_); + return writeIterator(iterableStack_.begin(), iterableStack_.end(), iterableStack_.size()); + } + template + inline MessageBuilder& operator<<(const std::priority_queue& priorityQueue_) { + base::workarounds::IterablePriorityQueue iterablePriorityQueue_ = + static_cast >(priorityQueue_); + return writeIterator(iterablePriorityQueue_.begin(), iterablePriorityQueue_.end(), iterablePriorityQueue_.size()); + } + template + inline MessageBuilder& operator<<(const std::pair& pair_) { + m_logger->stream() << ELPP_LITERAL("("); + operator << (static_cast(pair_.first)); + m_logger->stream() << ELPP_LITERAL(", "); + operator << (static_cast(pair_.second)); + m_logger->stream() << ELPP_LITERAL(")"); + return *this; + } + template + inline MessageBuilder& operator<<(const std::bitset& bitset_) { + m_logger->stream() << ELPP_LITERAL("["); + operator << (bitset_.to_string()); + m_logger->stream() << ELPP_LITERAL("]"); + return *this; + } +# if defined(ELPP_LOG_STD_ARRAY) + template + inline MessageBuilder& operator<<(const std::array& array) { + return writeIterator(array.begin(), array.end(), array.size()); + } +# endif // defined(ELPP_LOG_STD_ARRAY) +# if defined(ELPP_LOG_UNORDERED_MAP) + ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG(std::unordered_map) + ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG(std::unordered_multimap) +# endif // defined(ELPP_LOG_UNORDERED_MAP) +# if defined(ELPP_LOG_UNORDERED_SET) + ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(std::unordered_set) + ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(std::unordered_multiset) +# endif // defined(ELPP_LOG_UNORDERED_SET) +#endif // defined(ELPP_STL_LOGGING) +#if defined(ELPP_QT_LOGGING) + inline MessageBuilder& operator<<(const QString& msg) { +# if defined(ELPP_UNICODE) + m_logger->stream() << msg.toStdWString(); +# else + m_logger->stream() << msg.toStdString(); +# endif // defined(ELPP_UNICODE) + return *this; + } + inline MessageBuilder& operator<<(const QByteArray& msg) { + return operator << (QString(msg)); + } + inline MessageBuilder& operator<<(const QStringRef& msg) { + return operator<<(msg.toString()); + } + inline MessageBuilder& operator<<(qint64 msg) { +# if defined(ELPP_UNICODE) + m_logger->stream() << QString::number(msg).toStdWString(); +# else + m_logger->stream() << QString::number(msg).toStdString(); +# endif // defined(ELPP_UNICODE) + return *this; + } + inline MessageBuilder& operator<<(quint64 msg) { +# if defined(ELPP_UNICODE) + m_logger->stream() << QString::number(msg).toStdWString(); +# else + m_logger->stream() << QString::number(msg).toStdString(); +# endif // defined(ELPP_UNICODE) + return *this; + } + inline MessageBuilder& operator<<(QChar msg) { + m_logger->stream() << msg.toLatin1(); + return *this; + } + inline MessageBuilder& operator<<(const QLatin1String& msg) { + m_logger->stream() << msg.latin1(); + return *this; + } + ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QList) + ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QVector) + ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QQueue) + ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QSet) + ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QLinkedList) + ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QStack) + template + inline MessageBuilder& operator<<(const QPair& pair_) { + m_logger->stream() << ELPP_LITERAL("("); + operator << (static_cast(pair_.first)); + m_logger->stream() << ELPP_LITERAL(", "); + operator << (static_cast(pair_.second)); + m_logger->stream() << ELPP_LITERAL(")"); + return *this; + } + template + inline MessageBuilder& operator<<(const QMap& map_) { + m_logger->stream() << ELPP_LITERAL("["); + QList keys = map_.keys(); + typename QList::const_iterator begin = keys.begin(); + typename QList::const_iterator end = keys.end(); + int max_ = static_cast(base::consts::kMaxLogPerContainer); // to prevent warning + for (int index_ = 0; begin != end && index_ < max_; ++index_, ++begin) { + m_logger->stream() << ELPP_LITERAL("("); + operator << (static_cast(*begin)); + m_logger->stream() << ELPP_LITERAL(", "); + operator << (static_cast(map_.value(*begin))); + m_logger->stream() << ELPP_LITERAL(")"); + m_logger->stream() << ((index_ < keys.size() -1) ? m_containerLogSeperator : ELPP_LITERAL("")); + } + if (begin != end) { + m_logger->stream() << ELPP_LITERAL("..."); + } + m_logger->stream() << ELPP_LITERAL("]"); + return *this; + } + template + inline MessageBuilder& operator<<(const QMultiMap& map_) { + operator << (static_cast>(map_)); + return *this; + } + template + inline MessageBuilder& operator<<(const QHash& hash_) { + m_logger->stream() << ELPP_LITERAL("["); + QList keys = hash_.keys(); + typename QList::const_iterator begin = keys.begin(); + typename QList::const_iterator end = keys.end(); + int max_ = static_cast(base::consts::kMaxLogPerContainer); // prevent type warning + for (int index_ = 0; begin != end && index_ < max_; ++index_, ++begin) { + m_logger->stream() << ELPP_LITERAL("("); + operator << (static_cast(*begin)); + m_logger->stream() << ELPP_LITERAL(", "); + operator << (static_cast(hash_.value(*begin))); + m_logger->stream() << ELPP_LITERAL(")"); + m_logger->stream() << ((index_ < keys.size() -1) ? m_containerLogSeperator : ELPP_LITERAL("")); + } + if (begin != end) { + m_logger->stream() << ELPP_LITERAL("..."); + } + m_logger->stream() << ELPP_LITERAL("]"); + return *this; + } + template + inline MessageBuilder& operator<<(const QMultiHash& multiHash_) { + operator << (static_cast>(multiHash_)); + return *this; + } +#endif // defined(ELPP_QT_LOGGING) +#if defined(ELPP_BOOST_LOGGING) + ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(boost::container::vector) + ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(boost::container::stable_vector) + ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(boost::container::list) + ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(boost::container::deque) + ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(boost::container::map) + ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(boost::container::flat_map) + ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(boost::container::set) + ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(boost::container::flat_set) +#endif // defined(ELPP_BOOST_LOGGING) + +/// @brief Macro used internally that can be used externally to make containers easylogging++ friendly +/// +/// @detail This macro expands to write an ostream& operator<< for container. This container is expected to +/// have begin() and end() methods that return respective iterators +/// @param ContainerType Type of container e.g, MyList from WX_DECLARE_LIST(int, MyList); in wxwidgets +/// @param SizeMethod Method used to get size of container. +/// @param ElementInstance Instance of element to be fed out. Insance name is "elem". See WXELPP_ENABLED macro +/// for an example usage +#define MAKE_CONTAINERELPP_FRIENDLY(ContainerType, SizeMethod, ElementInstance) \ + el::base::type::ostream_t& operator<<(el::base::type::ostream_t& ss, const ContainerType& container) {\ + const el::base::type::char_t* sep = ELPP->hasFlag(el::LoggingFlag::NewLineForContainer) ? \ + ELPP_LITERAL("\n ") : ELPP_LITERAL(", ");\ + ContainerType::const_iterator elem = container.begin();\ + ContainerType::const_iterator endElem = container.end();\ + std::size_t size_ = container.SizeMethod; \ + ss << ELPP_LITERAL("[");\ + for (std::size_t i = 0; elem != endElem && i < el::base::consts::kMaxLogPerContainer; ++i, ++elem) { \ + ss << ElementInstance;\ + ss << ((i < size_ - 1) ? sep : ELPP_LITERAL(""));\ + }\ + if (elem != endElem) {\ + ss << ELPP_LITERAL("...");\ + }\ + ss << ELPP_LITERAL("]");\ + return ss;\ + } +#if defined(ELPP_WXWIDGETS_LOGGING) + ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(wxVector) +# define ELPP_WX_PTR_ENABLED(ContainerType) MAKE_CONTAINERELPP_FRIENDLY(ContainerType, size(), *(*elem)) +# define ELPP_WX_ENABLED(ContainerType) MAKE_CONTAINERELPP_FRIENDLY(ContainerType, size(), (*elem)) +# define ELPP_WX_HASH_MAP_ENABLED(ContainerType) MAKE_CONTAINERELPP_FRIENDLY(ContainerType, size(), \ + ELPP_LITERAL("(") << elem->first << ELPP_LITERAL(", ") << elem->second << ELPP_LITERAL(")") +#else +# define ELPP_WX_PTR_ENABLED(ContainerType) +# define ELPP_WX_ENABLED(ContainerType) +# define ELPP_WX_HASH_MAP_ENABLED(ContainerType) +#endif // defined(ELPP_WXWIDGETS_LOGGING) + // Other classes + template + ELPP_SIMPLE_LOG(const Class&) +#undef ELPP_SIMPLE_LOG +#undef ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG +#undef ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG +#undef ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG +#undef ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG +#undef ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG +private: + Logger* m_logger; + const base::type::char_t* m_containerLogSeperator; + + template + inline MessageBuilder& writeIterator(Iterator begin_, Iterator end_, std::size_t size_) { + m_logger->stream() << ELPP_LITERAL("["); + for (std::size_t i = 0; begin_ != end_ && i < base::consts::kMaxLogPerContainer; ++i, ++begin_) { + operator << (*begin_); + m_logger->stream() << ((i < size_ - 1) ? m_containerLogSeperator : ELPP_LITERAL("")); + } + if (begin_ != end_) { + m_logger->stream() << ELPP_LITERAL("..."); + } + m_logger->stream() << ELPP_LITERAL("]"); + if (ELPP->hasFlag(LoggingFlag::AutoSpacing)) { + m_logger->stream() << " "; + } + return *this; + } +}; +/// @brief Writes nothing - Used when certain log is disabled +class NullWriter : base::NoCopy { +public: + NullWriter(void) {} + + // Null manipulator + inline NullWriter& operator<<(std::ostream& (*)(std::ostream&)) { + return *this; + } + + template + inline NullWriter& operator<<(const T&) { + return *this; + } +}; +/// @brief Main entry point of each logging +class Writer : base::NoCopy { +public: + Writer(Level level, const char* file, unsigned long int line, + const char* func, base::DispatchAction dispatchAction = base::DispatchAction::NormalLog, + base::type::VerboseLevel verboseLevel = 0) : + m_level(level), m_file(file), m_line(line), m_func(func), m_verboseLevel(verboseLevel), + m_proceed(false), m_dispatchAction(dispatchAction) { + } + + virtual ~Writer(void) { + processDispatch(); + } + + template + inline Writer& operator<<(const T& log) { +#if ELPP_LOGGING_ENABLED + if (m_proceed) { + m_messageBuilder << log; + } +#endif // ELPP_LOGGING_ENABLED + return *this; + } + + inline Writer& operator<<(std::ostream& (*log)(std::ostream&)) { +#if ELPP_LOGGING_ENABLED + if (m_proceed) { + m_messageBuilder << log; + } +#endif // ELPP_LOGGING_ENABLED + return *this; + } + + Writer& construct(Logger* logger, bool needLock = true) { + m_logger = logger; + initializeLogger(logger->id(), false, needLock); + m_messageBuilder.initialize(m_logger); + return *this; + } + + Writer& construct(int count, const char* loggerIds, ...) { + if (ELPP->hasFlag(LoggingFlag::MultiLoggerSupport)) { + va_list loggersList; + va_start(loggersList, loggerIds); + const char* id = loggerIds; + for (int i = 0; i < count; ++i) { + m_loggerIds.push_back(std::string(id)); + id = va_arg(loggersList, const char*); + } + va_end(loggersList); + initializeLogger(m_loggerIds.at(0)); + } else { + initializeLogger(std::string(loggerIds)); + } + m_messageBuilder.initialize(m_logger); + return *this; + } +protected: + Level m_level; + const char* m_file; + const unsigned long int m_line; + const char* m_func; + base::type::VerboseLevel m_verboseLevel; + Logger* m_logger; + bool m_proceed; + base::MessageBuilder m_messageBuilder; + base::DispatchAction m_dispatchAction; + std::vector m_loggerIds; + friend class el::Helpers; + + void initializeLogger(const std::string& loggerId, bool lookup = true, bool needLock = true) { + if (lookup) { + m_logger = ELPP->registeredLoggers()->get(loggerId, ELPP->hasFlag(LoggingFlag::CreateLoggerAutomatically)); + } + if (m_logger == nullptr) { + ELPP->acquireLock(); + if (!ELPP->registeredLoggers()->has(std::string(base::consts::kDefaultLoggerId))) { + // Somehow default logger has been unregistered. Not good! Register again + ELPP->registeredLoggers()->get(std::string(base::consts::kDefaultLoggerId)); + } + ELPP->releaseLock(); // Need to unlock it for next writer + Writer(Level::Debug, m_file, m_line, m_func).construct(1, base::consts::kDefaultLoggerId) + << "Logger [" << loggerId << "] is not registered yet!"; + m_proceed = false; + } else { + if (needLock) { + m_logger->acquireLock(); // This should not be unlocked by checking m_proceed because + // m_proceed can be changed by lines below + } + if (ELPP->hasFlag(LoggingFlag::HierarchicalLogging)) { + m_proceed = m_level == Level::Verbose ? m_logger->enabled(m_level) : + LevelHelper::castToInt(m_level) >= LevelHelper::castToInt(ELPP->m_loggingLevel); + } else { + m_proceed = m_logger->enabled(m_level); + } + } + } + + void processDispatch() { +#if ELPP_LOGGING_ENABLED + if (ELPP->hasFlag(LoggingFlag::MultiLoggerSupport)) { + bool firstDispatched = false; + base::type::string_t logMessage; + std::size_t i = 0; + do { + if (m_proceed) { + if (firstDispatched) { + m_logger->stream() << logMessage; + } else { + firstDispatched = true; + if (m_loggerIds.size() > 1) { + logMessage = m_logger->stream().str(); + } + } + triggerDispatch(); + } else if (m_logger != nullptr) { + m_logger->stream().str(ELPP_LITERAL("")); + m_logger->releaseLock(); + } + if (i + 1 < m_loggerIds.size()) { + initializeLogger(m_loggerIds.at(i + 1)); + } + } while (++i < m_loggerIds.size()); + } else { + if (m_proceed) { + triggerDispatch(); + } else if (m_logger != nullptr) { + m_logger->stream().str(ELPP_LITERAL("")); + m_logger->releaseLock(); + } + } +#else + if (m_logger != nullptr) { + m_logger->stream().str(ELPP_LITERAL("")); + m_logger->releaseLock(); + } +#endif // ELPP_LOGGING_ENABLED + } + + void triggerDispatch(void) { + if (m_proceed) { + base::LogDispatcher(m_proceed, LogMessage(m_level, m_file, m_line, m_func, m_verboseLevel, + m_logger), m_dispatchAction).dispatch(); + } + if (m_logger != nullptr) { + m_logger->stream().str(ELPP_LITERAL("")); + m_logger->releaseLock(); + } + if (m_proceed && m_level == Level::Fatal + && !ELPP->hasFlag(LoggingFlag::DisableApplicationAbortOnFatalLog)) { + base::Writer(Level::Warning, m_file, m_line, m_func).construct(1, base::consts::kDefaultLoggerId) + << "Aborting application. Reason: Fatal log at [" << m_file << ":" << m_line << "]"; + std::stringstream reasonStream; + reasonStream << "Fatal log at [" << m_file << ":" << m_line << "]" + << " If you wish to disable 'abort on fatal log' please use " + << "el::Helpers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog)"; + base::utils::abort(1, reasonStream.str()); + } + m_proceed = false; + } +}; +class PErrorWriter : public base::Writer { +public: + PErrorWriter(Level level, const char* file, unsigned long int line, + const char* func, base::DispatchAction dispatchAction = base::DispatchAction::NormalLog, + base::type::VerboseLevel verboseLevel = 0) : + base::Writer(level, file, line, func, dispatchAction, verboseLevel) { + } + + virtual ~PErrorWriter(void) { + if (m_proceed) { +#if ELPP_COMPILER_MSVC + char buff[256]; + strerror_s(buff, 256, errno); + m_logger->stream() << ": " << buff << " [" << errno << "]"; +#else + m_logger->stream() << ": " << strerror(errno) << " [" << errno << "]"; +#endif + } + } +}; +} // namespace base +// Logging from Logger class. Why this is here? Because we have Storage and Writer class available +#if ELPP_VARIADIC_TEMPLATES_SUPPORTED + template + void Logger::log_(Level level, int vlevel, const char* s, const T& value, const Args&... args) { + base::MessageBuilder b; + b.initialize(this); + while (*s) { + if (*s == base::consts::kFormatSpecifierChar) { + if (*(s + 1) == base::consts::kFormatSpecifierChar) { + ++s; + } else { + if (*(s + 1) == base::consts::kFormatSpecifierCharValue) { + ++s; + b << value; + log_(level, vlevel, ++s, args...); + return; + } + } + } + b << *s++; + } + ELPP_INTERNAL_ERROR("Too many arguments provided. Unable to handle. Please provide more format specifiers", false); + } + template + inline void Logger::log_(Level level, int vlevel, const T& log) { + if (level == Level::Verbose) { + if (ELPP->vRegistry()->allowed(vlevel, __FILE__)) { + base::Writer(Level::Verbose, "FILE", 0, "FUNCTION", + base::DispatchAction::NormalLog, vlevel).construct(this, false) << log; + } else { + stream().str(ELPP_LITERAL("")); + } + } else { + base::Writer(level, "FILE", 0, "FUNCTION").construct(this, false) << log; + } + } + template + void Logger::log(Level level, const char* s, const T& value, const Args&... args) { + base::threading::ScopedLock scopedLock(lock()); + log_(level, 0, s, value, args...); + } + template + inline void Logger::log(Level level, const T& log) { + base::threading::ScopedLock scopedLock(lock()); + log_(level, 0, log); + } +# if ELPP_VERBOSE_LOG + template + inline void Logger::verbose(int vlevel, const char* s, const T& value, const Args&... args) { + base::threading::ScopedLock scopedLock(lock()); + log_(el::Level::Verbose, vlevel, s, value, args...); + } + template + inline void Logger::verbose(int vlevel, const T& log) { + base::threading::ScopedLock scopedLock(lock()); + log_(el::Level::Verbose, vlevel, log); + } +# else + template + inline void Logger::verbose(int, const char*, const T&, const Args&...) { + return; + } + template + inline void Logger::verbose(int, const T&) { + return; + } +# endif // ELPP_VERBOSE_LOG +# define LOGGER_LEVEL_WRITERS(FUNCTION_NAME, LOG_LEVEL)\ + template \ + inline void Logger::FUNCTION_NAME(const char* s, const T& value, const Args&... args) {\ + log(LOG_LEVEL, s, value, args...);\ + }\ + template \ + inline void Logger::FUNCTION_NAME(const T& value) {\ + log(LOG_LEVEL, value);\ + } +# define LOGGER_LEVEL_WRITERS_DISABLED(FUNCTION_NAME, LOG_LEVEL)\ + template \ + inline void Logger::FUNCTION_NAME(const char*, const T&, const Args&...) {\ + return;\ + }\ + template \ + inline void Logger::FUNCTION_NAME(const T&) {\ + return;\ + } + +# if ELPP_INFO_LOG + LOGGER_LEVEL_WRITERS(info, Level::Info) +# else + LOGGER_LEVEL_WRITERS_DISABLED(info, Level::Info) +# endif // ELPP_INFO_LOG +# if ELPP_DEBUG_LOG + LOGGER_LEVEL_WRITERS(debug, Level::Debug) +# else + LOGGER_LEVEL_WRITERS_DISABLED(debug, Level::Debug) +# endif // ELPP_DEBUG_LOG +# if ELPP_WARNING_LOG + LOGGER_LEVEL_WRITERS(warn, Level::Warning) +# else + LOGGER_LEVEL_WRITERS_DISABLED(warn, Level::Warning) +# endif // ELPP_WARNING_LOG +# if ELPP_ERROR_LOG + LOGGER_LEVEL_WRITERS(error, Level::Error) +# else + LOGGER_LEVEL_WRITERS_DISABLED(error, Level::Error) +# endif // ELPP_ERROR_LOG +# if ELPP_FATAL_LOG + LOGGER_LEVEL_WRITERS(fatal, Level::Fatal) +# else + LOGGER_LEVEL_WRITERS_DISABLED(fatal, Level::Fatal) +# endif // ELPP_FATAL_LOG +# if ELPP_TRACE_LOG + LOGGER_LEVEL_WRITERS(trace, Level::Trace) +# else + LOGGER_LEVEL_WRITERS_DISABLED(trace, Level::Trace) +# endif // ELPP_TRACE_LOG +# undef LOGGER_LEVEL_WRITERS +# undef LOGGER_LEVEL_WRITERS_DISABLED +#endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED +#if ELPP_COMPILER_MSVC +# define ELPP_VARIADIC_FUNC_MSVC(variadicFunction, variadicArgs) variadicFunction variadicArgs +# define ELPP_VARIADIC_FUNC_MSVC_RUN(variadicFunction, ...) ELPP_VARIADIC_FUNC_MSVC(variadicFunction, (__VA_ARGS__)) +# define el_getVALength(...) ELPP_VARIADIC_FUNC_MSVC_RUN(el_resolveVALength, 0, ## __VA_ARGS__,\ + 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) +#else +# if ELPP_COMPILER_CLANG +# define el_getVALength(...) el_resolveVALength(0, __VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) +# else +# define el_getVALength(...) el_resolveVALength(0, ## __VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) +# endif // ELPP_COMPILER_CLANG +#endif // ELPP_COMPILER_MSVC +#define el_resolveVALength(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N +#define ELPP_WRITE_LOG(writer, level, dispatchAction, ...) \ + writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) +#define ELPP_WRITE_LOG_IF(writer, condition, level, dispatchAction, ...) if (condition) \ + writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) +#define ELPP_WRITE_LOG_EVERY_N(writer, occasion, level, dispatchAction, ...) \ + if (ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion)) \ + writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) +#define ELPP_WRITE_LOG_AFTER_N(writer, n, level, dispatchAction, ...) \ + if (ELPP->validateAfterNCounter(__FILE__, __LINE__, n)) \ + writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) +#define ELPP_WRITE_LOG_N_TIMES(writer, n, level, dispatchAction, ...) \ + if (ELPP->validateNTimesCounter(__FILE__, __LINE__, n)) \ + writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) +#undef ELPP_CURR_FILE_PERFORMANCE_LOGGER +#if defined(ELPP_PERFORMANCE_LOGGER) +# define ELPP_CURR_FILE_PERFORMANCE_LOGGER ELPP_PERFORMANCE_LOGGER +#else +# define ELPP_CURR_FILE_PERFORMANCE_LOGGER el::base::consts::kPerformanceLoggerId +#endif +class PerformanceTrackingData { +public: + enum class DataType : base::type::EnumType { + Checkpoint = 1, Complete = 2 + }; + // Do not use constructor, will run into multiple definition error, use init(PerformanceTracker*) + explicit PerformanceTrackingData(DataType dataType) : m_performanceTracker(nullptr), + m_dataType(dataType), m_file(""), m_line(0), m_func("") {} + inline const std::string* blockName(void) const; + inline const struct timeval* startTime(void) const; + inline const struct timeval* endTime(void) const; + inline const struct timeval* lastCheckpointTime(void) const; + inline const base::PerformanceTracker* performanceTracker(void) const { return m_performanceTracker; } + inline PerformanceTrackingData::DataType dataType(void) const { return m_dataType; } + inline bool firstCheckpoint(void) const { return m_firstCheckpoint; } + inline std::string checkpointId(void) const { return m_checkpointId; } + inline const char* file(void) const { return m_file; } + inline unsigned long int line(void) const { return m_line; } + inline const char* func(void) const { return m_func; } + inline const base::type::string_t* formattedTimeTaken() const { return &m_formattedTimeTaken; } + inline const std::string& loggerId(void) const; +private: + base::PerformanceTracker* m_performanceTracker; + base::type::string_t m_formattedTimeTaken; + PerformanceTrackingData::DataType m_dataType; + bool m_firstCheckpoint; + std::string m_checkpointId; + const char* m_file; + unsigned long int m_line; + const char* m_func; + inline void init(base::PerformanceTracker* performanceTracker, bool firstCheckpoint = false) { + m_performanceTracker = performanceTracker; + m_firstCheckpoint = firstCheckpoint; + } + + friend class el::base::PerformanceTracker; +}; +namespace base { +/// @brief Represents performanceTracker block of code that conditionally adds performance status to log +/// either when goes outside the scope of when checkpoint() is called +class PerformanceTracker : public base::threading::ThreadSafe, public Loggable { +public: + PerformanceTracker(const std::string& blockName, + base::TimestampUnit timestampUnit = base::TimestampUnit::Millisecond, + const std::string& loggerId = std::string(ELPP_CURR_FILE_PERFORMANCE_LOGGER), + bool scopedLog = true, Level level = base::consts::kPerformanceTrackerDefaultLevel) : + m_blockName(blockName), m_timestampUnit(timestampUnit), m_loggerId(loggerId), m_scopedLog(scopedLog), + m_level(level), m_hasChecked(false), m_lastCheckpointId(std::string()), m_enabled(false) { +#if !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED + // We store it locally so that if user happen to change configuration by the end of scope + // or before calling checkpoint, we still depend on state of configuraton at time of construction + el::Logger* loggerPtr = ELPP->registeredLoggers()->get(loggerId, false); + m_enabled = loggerPtr != nullptr && loggerPtr->m_typedConfigurations->performanceTracking(m_level); + if (m_enabled) { + base::utils::DateTime::gettimeofday(&m_startTime); + } +#endif // !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED + } + /// @brief Copy constructor + PerformanceTracker(const PerformanceTracker& t) : + m_blockName(t.m_blockName), m_timestampUnit(t.m_timestampUnit), m_loggerId(t.m_loggerId), m_scopedLog(t.m_scopedLog), + m_level(t.m_level), m_hasChecked(t.m_hasChecked), m_lastCheckpointId(t.m_lastCheckpointId), m_enabled(t.m_enabled), + m_startTime(t.m_startTime), m_endTime(t.m_endTime), m_lastCheckpointTime(t.m_lastCheckpointTime) { + } + virtual ~PerformanceTracker(void) { +#if !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED + if (m_enabled) { + base::threading::ScopedLock scopedLock(lock()); + if (m_scopedLog) { + base::utils::DateTime::gettimeofday(&m_endTime); + base::type::string_t formattedTime = getFormattedTimeTaken(); + PerformanceTrackingData data(PerformanceTrackingData::DataType::Complete); + data.init(this); + data.m_formattedTimeTaken = formattedTime; + PerformanceTrackingCallback* callback = nullptr; + for (const std::pair& h + : ELPP->m_performanceTrackingCallbacks) { + callback = h.second.get(); + if (callback != nullptr && callback->enabled()) { + callback->acquireLock(); + callback->handle(&data); + callback->releaseLock(); + } + } + } + } +#endif // !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) + } + /// @brief A checkpoint for current performanceTracker block. + void checkpoint(const std::string& id = std::string(), const char* file = __FILE__, unsigned long int line = __LINE__, const char* func = "") { +#if !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED + if (m_enabled) { + base::threading::ScopedLock scopedLock(lock()); + base::utils::DateTime::gettimeofday(&m_endTime); + base::type::string_t formattedTime = m_hasChecked ? getFormattedTimeTaken(m_lastCheckpointTime) : ELPP_LITERAL(""); + PerformanceTrackingData data(PerformanceTrackingData::DataType::Checkpoint); + data.init(this); + data.m_checkpointId = id; + data.m_file = file; + data.m_line = line; + data.m_func = func; + data.m_formattedTimeTaken = formattedTime; + PerformanceTrackingCallback* callback = nullptr; + for (const std::pair& h + : ELPP->m_performanceTrackingCallbacks) { + callback = h.second.get(); + if (callback != nullptr && callback->enabled()) { + callback->acquireLock(); + callback->handle(&data); + callback->releaseLock(); + } + } + base::utils::DateTime::gettimeofday(&m_lastCheckpointTime); + m_hasChecked = true; + m_lastCheckpointId = id; + } +#endif // !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED + ELPP_UNUSED(id); + ELPP_UNUSED(file); + ELPP_UNUSED(line); + ELPP_UNUSED(func); + } + inline Level level(void) const { return m_level; } +private: + std::string m_blockName; + base::TimestampUnit m_timestampUnit; + std::string m_loggerId; + bool m_scopedLog; + Level m_level; + bool m_hasChecked; + std::string m_lastCheckpointId; + bool m_enabled; + struct timeval m_startTime, m_endTime, m_lastCheckpointTime; + + PerformanceTracker(void); + + friend class el::PerformanceTrackingData; + friend class base::DefaultPerformanceTrackingCallback; + + const inline base::type::string_t getFormattedTimeTaken() const { + return getFormattedTimeTaken(m_startTime); + } + + const base::type::string_t getFormattedTimeTaken(struct timeval startTime) const { + if (ELPP->hasFlag(LoggingFlag::FixedTimeFormat)) { + base::type::stringstream_t ss; + ss << base::utils::DateTime::getTimeDifference(m_endTime, + startTime, m_timestampUnit) << " " << base::consts::kTimeFormats[static_cast(m_timestampUnit)].unit; + return ss.str(); + } + return base::utils::DateTime::formatTime(base::utils::DateTime::getTimeDifference(m_endTime, + startTime, m_timestampUnit), m_timestampUnit); + } + + virtual inline void log(el::base::type::ostream_t& os) const { + os << getFormattedTimeTaken(); + } +}; +class DefaultPerformanceTrackingCallback : public PerformanceTrackingCallback { +protected: + void handle(const PerformanceTrackingData* data) { + m_data = data; + base::type::stringstream_t ss; + if (m_data->dataType() == PerformanceTrackingData::DataType::Complete) { + ss << ELPP_LITERAL("Executed [") << m_data->blockName()->c_str() << ELPP_LITERAL("] in [") << *m_data->formattedTimeTaken() << ELPP_LITERAL("]"); + } else { + ss << ELPP_LITERAL("Performance checkpoint"); + if (!m_data->checkpointId().empty()) { + ss << ELPP_LITERAL(" [") << m_data->checkpointId().c_str() << ELPP_LITERAL("]"); + } + ss << ELPP_LITERAL(" for block [") << m_data->blockName()->c_str() << ELPP_LITERAL("] : [") << *m_data->performanceTracker(); + if (!ELPP->hasFlag(LoggingFlag::DisablePerformanceTrackingCheckpointComparison) && m_data->performanceTracker()->m_hasChecked) { + ss << ELPP_LITERAL(" ([") << *m_data->formattedTimeTaken() << ELPP_LITERAL("] from "); + if (m_data->performanceTracker()->m_lastCheckpointId.empty()) { + ss << ELPP_LITERAL("last checkpoint"); + } else { + ss << ELPP_LITERAL("checkpoint '") << m_data->performanceTracker()->m_lastCheckpointId.c_str() << ELPP_LITERAL("'"); + } + ss << ELPP_LITERAL(")]"); + } else { + ss << ELPP_LITERAL("]"); + } + } + el::base::Writer(m_data->performanceTracker()->level(), m_data->file(), m_data->line(), m_data->func()).construct(1, m_data->loggerId().c_str()) << ss.str(); + } +private: + const PerformanceTrackingData* m_data; +}; +} // namespace base +inline const std::string* PerformanceTrackingData::blockName() const { + return const_cast(&m_performanceTracker->m_blockName); +} +inline const struct timeval* PerformanceTrackingData::startTime() const { + return const_cast(&m_performanceTracker->m_startTime); +} +inline const struct timeval* PerformanceTrackingData::endTime() const { + return const_cast(&m_performanceTracker->m_endTime); +} +inline const struct timeval* PerformanceTrackingData::lastCheckpointTime() const { + return const_cast(&m_performanceTracker->m_lastCheckpointTime); +} +inline const std::string& PerformanceTrackingData::loggerId(void) const { return m_performanceTracker->m_loggerId; } +namespace base { +/// @brief Contains some internal debugging tools like crash handler and stack tracer +namespace debug { +class StackTrace : base::NoCopy { +public: + static const std::size_t kMaxStack = 64; + static const std::size_t kStackStart = 2; // We want to skip c'tor and StackTrace::generateNew() + class StackTraceEntry { + public: + StackTraceEntry(std::size_t index, const char* loc, const char* demang, const char* hex, const char* addr) { + m_index = index; + m_location = std::string(loc); + m_demangled = std::string(demang); + m_hex = std::string(hex); + m_addr = std::string(addr); + } + StackTraceEntry(std::size_t index, char* loc) { + m_index = index; + m_location = std::string(loc); + } + std::size_t m_index; + std::string m_location; + std::string m_demangled; + std::string m_hex; + std::string m_addr; + friend std::ostream& operator<<(std::ostream& ss, const StackTraceEntry& si) { + ss << "[" << si.m_index << "] " << si.m_location << (si.m_demangled.empty() ? "" : ":") << si.m_demangled + << (si.m_hex.empty() ? "" : "+") << si.m_hex << si.m_addr; + return ss; + } + + private: + StackTraceEntry(void); + }; + + StackTrace(void) { + generateNew(); + } + + virtual ~StackTrace(void) { + } + + inline std::vector& getLatestStack(void) { + return m_stack; + } + + friend inline std::ostream& operator<<(std::ostream& os, const StackTrace& st) { + std::vector::const_iterator it = st.m_stack.begin(); + while (it != st.m_stack.end()) { + os << " " << *it++ << "\n"; + } + return os; + } + +private: + std::vector m_stack; + + void generateNew(void) { +#if ELPP_STACKTRACE + m_stack.clear(); + void* stack[kMaxStack]; + std::size_t size = backtrace(stack, kMaxStack); + char** strings = backtrace_symbols(stack, size); + if (size > kStackStart) { // Skip StackTrace c'tor and generateNew + for (std::size_t i = kStackStart; i < size; ++i) { + char* mangName = nullptr; + char* hex = nullptr; + char* addr = nullptr; + for (char* c = strings[i]; *c; ++c) { + switch (*c) { + case '(': + mangName = c; + break; + case '+': + hex = c; + break; + case ')': + addr = c; + break; + } + } + // Perform demangling if parsed properly + if (mangName != nullptr && hex != nullptr && addr != nullptr && mangName < hex) { + *mangName++ = '\0'; + *hex++ = '\0'; + *addr++ = '\0'; + int status = 0; + char* demangName = abi::__cxa_demangle(mangName, 0, 0, &status); + // if demangling is successful, output the demangled function name + if (status == 0) { + // Success (see http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.3/a01696.html) + StackTraceEntry entry(i - 1, strings[i], demangName, hex, addr); + m_stack.push_back(entry); + } else { + // Not successful - we will use mangled name + StackTraceEntry entry(i - 1, strings[i], mangName, hex, addr); + m_stack.push_back(entry); + } + free(demangName); + } else { + StackTraceEntry entry(i - 1, strings[i]); + m_stack.push_back(entry); + } + } + } + free(strings); +#else + ELPP_INTERNAL_INFO(1, "Stacktrace generation not supported for selected compiler"); +#endif // ELPP_STACKTRACE + } +}; +static std::string crashReason(int sig) { + std::stringstream ss; + bool foundReason = false; + for (int i = 0; i < base::consts::kCrashSignalsCount; ++i) { + if (base::consts::kCrashSignals[i].numb == sig) { + ss << "Application has crashed due to [" << base::consts::kCrashSignals[i].name << "] signal"; + if (ELPP->hasFlag(el::LoggingFlag::LogDetailedCrashReason)) { + ss << std::endl << + " " << base::consts::kCrashSignals[i].brief << std::endl << + " " << base::consts::kCrashSignals[i].detail; + } + foundReason = true; + } + } + if (!foundReason) { + ss << "Application has crashed due to unknown signal [" << sig << "]"; + } + return ss.str(); +} +/// @brief Logs reason of crash from sig +static void logCrashReason(int sig, bool stackTraceIfAvailable, Level level, const char* logger) { + std::stringstream ss; + ss << "CRASH HANDLED; "; + ss << crashReason(sig); +#if ELPP_STACKTRACE + if (stackTraceIfAvailable) { + ss << std::endl << " ======= Backtrace: =========" << std::endl << base::debug::StackTrace(); + } +#else + ELPP_UNUSED(stackTraceIfAvailable); +#endif // ELPP_STACKTRACE + ELPP_WRITE_LOG(el::base::Writer, level, base::DispatchAction::NormalLog, logger) << ss.str(); +} +static inline void crashAbort(int sig) { + base::utils::abort(sig); +} +/// @brief Default application crash handler +/// +/// @detail This function writes log using 'default' logger, prints stack trace for GCC based compilers and aborts program. +static inline void defaultCrashHandler(int sig) { + base::debug::logCrashReason(sig, true, Level::Fatal, base::consts::kDefaultLoggerId); + base::debug::crashAbort(sig); +} +/// @brief Handles unexpected crashes +class CrashHandler : base::NoCopy { +public: + typedef void (*Handler)(int); + + explicit CrashHandler(bool useDefault) { + if (useDefault) { + setHandler(defaultCrashHandler); + } + } + explicit CrashHandler(const Handler& cHandler) { + setHandler(cHandler); + } + void setHandler(const Handler& cHandler) { + m_handler = cHandler; +#if defined(ELPP_HANDLE_SIGABRT) + int i = 0; // SIGABRT is at base::consts::kCrashSignals[0] +#else + int i = 1; +#endif // defined(ELPP_HANDLE_SIGABRT) + for (; i < base::consts::kCrashSignalsCount; ++i) { + m_handler = signal(base::consts::kCrashSignals[i].numb, cHandler); + } + } + +private: + Handler m_handler; +}; +} // namespace debug +} // namespace base +extern base::debug::CrashHandler elCrashHandler; +#define MAKE_LOGGABLE(ClassType, ClassInstance, OutputStreamInstance) \ + el::base::type::ostream_t& operator<<(el::base::type::ostream_t& OutputStreamInstance, const ClassType& ClassInstance) +/// @brief Initializes syslog with process ID, options and facility. calls closelog() on d'tor +class SysLogInitializer { +public: + SysLogInitializer(const char* processIdent, int options = 0, int facility = 0) { +#if defined(ELPP_SYSLOG) + openlog(processIdent, options, facility); +#else + ELPP_UNUSED(processIdent); + ELPP_UNUSED(options); + ELPP_UNUSED(facility); +#endif // defined(ELPP_SYSLOG) + } + virtual ~SysLogInitializer(void) { +#if defined(ELPP_SYSLOG) + closelog(); +#endif // defined(ELPP_SYSLOG) + } +}; +#define ELPP_INITIALIZE_SYSLOG(id, opt, fac) el::SysLogInitializer elSyslogInit(id, opt, fac) +/// @brief Static helpers for developers +class Helpers : base::StaticClass { +public: + /// @brief Shares logging repository (base::Storage) + static inline void setStorage(base::type::StoragePointer storage) { + ELPP = storage; + } + /// @return Main storage repository + static inline base::type::StoragePointer storage() { + return ELPP; + } + /// @brief Sets application arguments and figures out whats active for logging and whats not. + static inline void setArgs(int argc, char** argv) { + ELPP->setApplicationArguments(argc, argv); + } + /// @copydoc setArgs(int argc, char** argv) + static inline void setArgs(int argc, const char** argv) { + ELPP->setApplicationArguments(argc, const_cast(argv)); + } + /// @brief Overrides default crash handler and installs custom handler. + /// @param crashHandler A functor with no return type that takes single int argument. + /// Handler is a typedef with specification: void (*Handler)(int) + static inline void setCrashHandler(const el::base::debug::CrashHandler::Handler& crashHandler) { + el::elCrashHandler.setHandler(crashHandler); + } + /// @brief Abort due to crash with signal in parameter + /// @param sig Crash signal + static inline void crashAbort(int sig, const char* sourceFile = "", unsigned int long line = 0) { + std::stringstream ss; + ss << base::debug::crashReason(sig).c_str(); + ss << " - [Called el::Helpers::crashAbort(" << sig << ")]"; + if (sourceFile != nullptr && strlen(sourceFile) > 0) { + ss << " - Source: " << sourceFile; + if (line > 0) + ss << ":" << line; + else + ss << " (line number not specified)"; + } + base::utils::abort(sig, ss.str()); + } + /// @brief Logs reason of crash as per sig + /// @param sig Crash signal + /// @param stackTraceIfAvailable Includes stack trace if available + /// @param level Logging level + /// @param logger Logger to use for logging + static inline void logCrashReason(int sig, bool stackTraceIfAvailable = false, + Level level = Level::Fatal, const char* logger = base::consts::kDefaultLoggerId) { + el::base::debug::logCrashReason(sig, stackTraceIfAvailable, level, logger); + } + /// @brief Installs pre rollout callback, this callback is triggered when log file is about to be rolled out + /// (can be useful for backing up) + static inline void installPreRollOutCallback(const PreRollOutCallback& callback) { + ELPP->setPreRollOutCallback(callback); + } + /// @brief Uninstalls pre rollout callback + static inline void uninstallPreRollOutCallback(void) { + ELPP->unsetPreRollOutCallback(); + } + /// @brief Installs post log dispatch callback, this callback is triggered when log is dispatched + template + static inline bool installLogDispatchCallback(const std::string& id) { + return ELPP->installLogDispatchCallback(id); + } + /// @brief Uninstalls log dispatch callback + template + static inline void uninstallLogDispatchCallback(const std::string& id) { + ELPP->uninstallLogDispatchCallback(id); + } + template + static inline T* logDispatchCallback(const std::string& id) { + return ELPP->logDispatchCallback(id); + } + /// @brief Installs post performance tracking callback, this callback is triggered when performance tracking is finished + template + static inline bool installPerformanceTrackingCallback(const std::string& id) { + return ELPP->installPerformanceTrackingCallback(id); + } + /// @brief Uninstalls post performance tracking handler + template + static inline void uninstallPerformanceTrackingCallback(const std::string& id) { + ELPP->uninstallPerformanceTrackingCallback(id); + } + template + static inline T* performanceTrackingCallback(const std::string& id) { + return ELPP->performanceTrackingCallback(id); + } + /// @brief Converts template to std::string - useful for loggable classes to log containers within log(std::ostream&) const + template + static std::string convertTemplateToStdString(const T& templ) { + el::Logger* logger = + ELPP->registeredLoggers()->get(el::base::consts::kDefaultLoggerId); + if (logger == nullptr) { + return std::string(); + } + base::MessageBuilder b; + b.initialize(logger); + logger->acquireLock(); + b << templ; +#if defined(ELPP_UNICODE) + std::string s = std::string(logger->stream().str().begin(), logger->stream().str().end()); +#else + std::string s = logger->stream().str(); +#endif // defined(ELPP_UNICODE) + logger->stream().str(ELPP_LITERAL("")); + logger->releaseLock(); + return s; + } + /// @brief Returns command line arguments (pointer) provided to easylogging++ + static inline const el::base::utils::CommandLineArgs* commandLineArgs(void) { + return ELPP->commandLineArgs(); + } + /// @brief Installs user defined format specifier and handler + static inline void installCustomFormatSpecifier(const CustomFormatSpecifier& customFormatSpecifier) { + ELPP->installCustomFormatSpecifier(customFormatSpecifier); + } + /// @brief Uninstalls user defined format specifier and handler + static inline bool uninstallCustomFormatSpecifier(const char* formatSpecifier) { + return ELPP->uninstallCustomFormatSpecifier(formatSpecifier); + } + /// @brief Returns true if custom format specifier is installed + static inline bool hasCustomFormatSpecifier(const char* formatSpecifier) { + return ELPP->hasCustomFormatSpecifier(formatSpecifier); + } + static inline void validateFileRolling(Logger* logger, Level level) { + if (logger == nullptr) return; + logger->m_typedConfigurations->validateFileRolling(level, ELPP->preRollOutCallback()); + } +}; +/// @brief Static helpers to deal with loggers and their configurations +class Loggers : base::StaticClass { +public: + /// @brief Gets existing or registers new logger + static inline Logger* getLogger(const std::string& identity, bool registerIfNotAvailable = true) { + base::threading::ScopedLock scopedLock(ELPP->lock()); + return ELPP->registeredLoggers()->get(identity, registerIfNotAvailable); + } + /// @brief Unregisters logger - use it only when you know what you are doing, you may unregister + /// loggers initialized / used by third-party libs. + static inline bool unregisterLogger(const std::string& identity) { + base::threading::ScopedLock scopedLock(ELPP->lock()); + return ELPP->registeredLoggers()->remove(identity); + } + /// @brief Whether or not logger with id is registered + static inline bool hasLogger(const std::string& identity) { + base::threading::ScopedLock scopedLock(ELPP->lock()); + return ELPP->registeredLoggers()->has(identity); + } + /// @brief Reconfigures specified logger with new configurations + static inline Logger* reconfigureLogger(Logger* logger, const Configurations& configurations) { + if (!logger) return nullptr; + logger->configure(configurations); + return logger; + } + /// @brief Reconfigures logger with new configurations after looking it up using identity + static inline Logger* reconfigureLogger(const std::string& identity, const Configurations& configurations) { + return Loggers::reconfigureLogger(Loggers::getLogger(identity), configurations); + } + /// @brief Reconfigures logger's single configuration + static inline Logger* reconfigureLogger(const std::string& identity, ConfigurationType configurationType, + const std::string& value) { + Logger* logger = Loggers::getLogger(identity); + if (logger == nullptr) { + return nullptr; + } + logger->configurations()->set(Level::Global, configurationType, value); + logger->reconfigure(); + return logger; + } + /// @brief Reconfigures all the existing loggers with new configurations + static inline void reconfigureAllLoggers(const Configurations& configurations) { + for (base::RegisteredLoggers::iterator it = ELPP->registeredLoggers()->begin(); + it != ELPP->registeredLoggers()->end(); ++it) { + Loggers::reconfigureLogger(it->second, configurations); + } + } + /// @brief Reconfigures single configuration for all the loggers + static inline void reconfigureAllLoggers(ConfigurationType configurationType, const std::string& value) { + reconfigureAllLoggers(Level::Global, configurationType, value); + } + /// @brief Reconfigures single configuration for all the loggers for specified level + static inline void reconfigureAllLoggers(Level level, ConfigurationType configurationType, + const std::string& value) { + for (base::RegisteredLoggers::iterator it = ELPP->registeredLoggers()->begin(); + it != ELPP->registeredLoggers()->end(); ++it) { + Logger* logger = it->second; + logger->configurations()->set(level, configurationType, value); + logger->reconfigure(); + } + } + /// @brief Sets default configurations. This configuration is used for future (and conditionally for existing) loggers + static inline void setDefaultConfigurations(const Configurations& configurations, bool reconfigureExistingLoggers = false) { + ELPP->registeredLoggers()->setDefaultConfigurations(configurations); + if (reconfigureExistingLoggers) { + Loggers::reconfigureAllLoggers(configurations); + } + } + /// @brief Returns current default + static inline const Configurations* defaultConfigurations(void) { + return ELPP->registeredLoggers()->defaultConfigurations(); + } + /// @brief Returns log stream reference pointer if needed by user + static inline const base::LogStreamsReferenceMap* logStreamsReference(void) { + return ELPP->registeredLoggers()->logStreamsReference(); + } + /// @brief Default typed configuration based on existing defaultConf + static base::TypedConfigurations defaultTypedConfigurations(void) { + return base::TypedConfigurations( + ELPP->registeredLoggers()->defaultConfigurations(), + ELPP->registeredLoggers()->logStreamsReference()); + } + /// @brief Populates all logger IDs in current repository. + /// @param [out] targetList List of fill up. + static inline std::vector* populateAllLoggerIds(std::vector* targetList) { + targetList->clear(); + for (base::RegisteredLoggers::iterator it = ELPP->registeredLoggers()->list().begin(); + it != ELPP->registeredLoggers()->list().end(); ++it) { + targetList->push_back(it->first); + } + return targetList; + } + /// @brief Sets configurations from global configuration file. + static void configureFromGlobal(const char* globalConfigurationFilePath) { + std::ifstream gcfStream(globalConfigurationFilePath, std::ifstream::in); + ELPP_ASSERT(gcfStream.is_open(), "Unable to open global configuration file [" << globalConfigurationFilePath + << "] for parsing."); + std::string line = std::string(); + std::stringstream ss; + Logger* logger = nullptr; + auto configure = [&](void) { + ELPP_INTERNAL_INFO(8, "Configuring logger: '" << logger->id() << "' with configurations \n" << ss.str() + << "\n--------------"); + Configurations c; + c.parseFromText(ss.str()); + logger->configure(c); + }; + while (gcfStream.good()) { + std::getline(gcfStream, line); + ELPP_INTERNAL_INFO(1, "Parsing line: " << line); + base::utils::Str::trim(line); + if (Configurations::Parser::isComment(line)) continue; + Configurations::Parser::ignoreComments(&line); + base::utils::Str::trim(line); + if (line.size() > 2 && base::utils::Str::startsWith(line, std::string(base::consts::kConfigurationLoggerId))) { + if (!ss.str().empty() && logger != nullptr) { + configure(); + } + ss.str(std::string("")); + line = line.substr(2); + base::utils::Str::trim(line); + if (line.size() > 1) { + ELPP_INTERNAL_INFO(1, "Getting logger: '" << line << "'"); + logger = getLogger(line); + } + } else { + ss << line << "\n"; + } + } + if (!ss.str().empty() && logger != nullptr) { + configure(); + } + } + /// @brief Configures loggers using command line arg. Ensure you have already set command line args, + /// @return False if invalid argument or argument with no value provided, true if attempted to configure logger. + /// If true is returned that does not mean it has been configured successfully, it only means that it + /// has attempeted to configure logger using configuration file provided in argument + static inline bool configureFromArg(const char* argKey) { +#if defined(ELPP_DISABLE_CONFIGURATION_FROM_PROGRAM_ARGS) + ELPP_UNUSED(argKey); +#else + if (!Helpers::commandLineArgs()->hasParamWithValue(argKey)) { + return false; + } + configureFromGlobal(Helpers::commandLineArgs()->getParamValue(argKey)); +#endif // defined(ELPP_DISABLE_CONFIGURATION_FROM_PROGRAM_ARGS) + return true; + } + /// @brief Flushes all loggers for all levels - Be careful if you dont know how many loggers are registered + static inline void flushAll(void) { + ELPP->registeredLoggers()->flushAll(); + } + /// @brief Adds logging flag used internally. + static inline void addFlag(LoggingFlag flag) { + ELPP->addFlag(flag); + } + /// @brief Removes logging flag used internally. + static inline void removeFlag(LoggingFlag flag) { + ELPP->removeFlag(flag); + } + /// @brief Determines whether or not certain flag is active + static inline bool hasFlag(LoggingFlag flag) { + return ELPP->hasFlag(flag); + } + /// @brief Adds flag and removes it when scope goes out + class ScopedAddFlag { + public: + ScopedAddFlag(LoggingFlag flag) : m_flag(flag) { Loggers::addFlag(m_flag); } + ~ScopedAddFlag(void) { Loggers::removeFlag(m_flag); } + private: + LoggingFlag m_flag; + }; + /// @brief Removes flag and add it when scope goes out + class ScopedRemoveFlag { + public: + ScopedRemoveFlag(LoggingFlag flag) : m_flag(flag) { Loggers::removeFlag(m_flag); } + ~ScopedRemoveFlag(void) { Loggers::addFlag(m_flag); } + private: + LoggingFlag m_flag; + }; + /// @brief Sets hierarchy for logging. Needs to enable logging flag (HierarchicalLogging) + static inline void setLoggingLevel(Level level) { + ELPP->setLoggingLevel(level); + } + /// @brief Sets verbose level on the fly + static inline void setVerboseLevel(base::type::VerboseLevel level) { + ELPP->vRegistry()->setLevel(level); + } + /// @brief Gets current verbose level + static inline base::type::VerboseLevel verboseLevel(void) { + return ELPP->vRegistry()->level(); + } + /// @brief Sets vmodules as specified (on the fly) + static inline void setVModules(const char* modules) { + if (ELPP->vRegistry()->vModulesEnabled()) { + ELPP->vRegistry()->setModules(modules); + } + } + /// @brief Clears vmodules + static inline void clearVModules(void) { + ELPP->vRegistry()->clearModules(); + } +}; +class VersionInfo : base::StaticClass { +public: + /// @brief Current version number + static inline const std::string version(void) { return std::string("9.80"); } + /// @brief Release date of current version + static inline const std::string releaseDate(void) { return std::string("08-01-2015 0850hrs"); } +}; +} // namespace el +#undef VLOG_IS_ON +/// @brief Determines whether verbose logging is on for specified level current file. +#define VLOG_IS_ON(verboseLevel) (ELPP->vRegistry()->allowed(verboseLevel, __FILE__)) +#undef TIMED_BLOCK +#undef TIMED_SCOPE +#undef TIMED_FUNC +#undef ELPP_MIN_UNIT +#if defined(ELPP_PERFORMANCE_MICROSECONDS) +# define ELPP_MIN_UNIT el::base::TimestampUnit::Microsecond +#else +# define ELPP_MIN_UNIT el::base::TimestampUnit::Millisecond +#endif // (defined(ELPP_PERFORMANCE_MICROSECONDS)) +/// @brief Performance tracked scope. Performance gets written when goes out of scope using +/// 'performance' logger. +/// +/// @detail Please note in order to check the performance at a certain time you can use obj.checkpoint(); +/// @see el::base::PerformanceTracker +/// @see el::base::PerformanceTracker::checkpoint +// Note: Do not surround this definition with null macro because of obj instance +#define TIMED_SCOPE(obj, blockname) el::base::PerformanceTracker obj(blockname, ELPP_MIN_UNIT) +#define TIMED_BLOCK(obj, blockName) for (struct { int i; el::base::PerformanceTracker timer; } obj = { 0, \ + el::base::PerformanceTracker(blockName, ELPP_MIN_UNIT) }; obj.i < 1; ++obj.i) +/// @brief Performance tracked function. Performance gets written when goes out of scope using +/// 'performance' logger. +/// +/// @detail Please note in order to check the performance at a certain time you can use obj.checkpoint(); +/// @see el::base::PerformanceTracker +/// @see el::base::PerformanceTracker::checkpoint +#define TIMED_FUNC(obj) TIMED_SCOPE(obj, ELPP_FUNC) +#undef PERFORMANCE_CHECKPOINT +#undef PERFORMANCE_CHECKPOINT_WITH_ID +#define PERFORMANCE_CHECKPOINT(obj) obj.checkpoint(std::string(), __FILE__, __LINE__, ELPP_FUNC) +#define PERFORMANCE_CHECKPOINT_WITH_ID(obj, id) obj.checkpoint(id, __FILE__, __LINE__, ELPP_FUNC) +#undef ELPP_COUNTER +#undef ELPP_COUNTER_POS +/// @brief Gets hit counter for file/line +#define ELPP_COUNTER (ELPP->hitCounters()->getCounter(__FILE__, __LINE__)) +/// @brief Gets hit counter position for file/line, -1 if not registered yet +#define ELPP_COUNTER_POS (ELPP_COUNTER == nullptr ? -1 : ELPP_COUNTER->hitCounts()) +// Undef levels to support LOG(LEVEL) +#undef INFO +#undef WARNING +#undef DEBUG +#undef ERROR +#undef FATAL +#undef TRACE +#undef VERBOSE +// Undef existing +#undef CINFO +#undef CWARNING +#undef CDEBUG +#undef CFATAL +#undef CERROR +#undef CTRACE +#undef CVERBOSE +#undef CINFO_IF +#undef CWARNING_IF +#undef CDEBUG_IF +#undef CERROR_IF +#undef CFATAL_IF +#undef CTRACE_IF +#undef CVERBOSE_IF +#undef CINFO_EVERY_N +#undef CWARNING_EVERY_N +#undef CDEBUG_EVERY_N +#undef CERROR_EVERY_N +#undef CFATAL_EVERY_N +#undef CTRACE_EVERY_N +#undef CVERBOSE_EVERY_N +#undef CINFO_AFTER_N +#undef CWARNING_AFTER_N +#undef CDEBUG_AFTER_N +#undef CERROR_AFTER_N +#undef CFATAL_AFTER_N +#undef CTRACE_AFTER_N +#undef CVERBOSE_AFTER_N +#undef CINFO_N_TIMES +#undef CWARNING_N_TIMES +#undef CDEBUG_N_TIMES +#undef CERROR_N_TIMES +#undef CFATAL_N_TIMES +#undef CTRACE_N_TIMES +#undef CVERBOSE_N_TIMES +// Normal logs +#if ELPP_INFO_LOG +# define CINFO(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Info, dispatchAction, __VA_ARGS__) +#else +# define CINFO(writer, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_INFO_LOG +#if ELPP_WARNING_LOG +# define CWARNING(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Warning, dispatchAction, __VA_ARGS__) +#else +# define CWARNING(writer, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_WARNING_LOG +#if ELPP_DEBUG_LOG +# define CDEBUG(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Debug, dispatchAction, __VA_ARGS__) +#else +# define CDEBUG(writer, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_DEBUG_LOG +#if ELPP_ERROR_LOG +# define CERROR(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Error, dispatchAction, __VA_ARGS__) +#else +# define CERROR(writer, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_ERROR_LOG +#if ELPP_FATAL_LOG +# define CFATAL(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Fatal, dispatchAction, __VA_ARGS__) +#else +# define CFATAL(writer, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_FATAL_LOG +#if ELPP_TRACE_LOG +# define CTRACE(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Trace, dispatchAction, __VA_ARGS__) +#else +# define CTRACE(writer, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_TRACE_LOG +#if ELPP_VERBOSE_LOG +# define CVERBOSE(writer, vlevel, dispatchAction, ...) if (VLOG_IS_ON(vlevel)) writer(\ + el::Level::Verbose, __FILE__, __LINE__, ELPP_FUNC, dispatchAction, vlevel).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) +#else +# define CVERBOSE(writer, vlevel, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_VERBOSE_LOG +// Conditional logs +#if ELPP_INFO_LOG +# define CINFO_IF(writer, condition_, dispatchAction, ...) \ + ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Info, dispatchAction, __VA_ARGS__) +#else +# define CINFO_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_INFO_LOG +#if ELPP_WARNING_LOG +# define CWARNING_IF(writer, condition_, dispatchAction, ...)\ + ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Warning, dispatchAction, __VA_ARGS__) +#else +# define CWARNING_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_WARNING_LOG +#if ELPP_DEBUG_LOG +# define CDEBUG_IF(writer, condition_, dispatchAction, ...)\ + ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Debug, dispatchAction, __VA_ARGS__) +#else +# define CDEBUG_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_DEBUG_LOG +#if ELPP_ERROR_LOG +# define CERROR_IF(writer, condition_, dispatchAction, ...)\ + ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Error, dispatchAction, __VA_ARGS__) +#else +# define CERROR_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_ERROR_LOG +#if ELPP_FATAL_LOG +# define CFATAL_IF(writer, condition_, dispatchAction, ...)\ + ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Fatal, dispatchAction, __VA_ARGS__) +#else +# define CFATAL_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_FATAL_LOG +#if ELPP_TRACE_LOG +# define CTRACE_IF(writer, condition_, dispatchAction, ...)\ + ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Trace, dispatchAction, __VA_ARGS__) +#else +# define CTRACE_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_TRACE_LOG +#if ELPP_VERBOSE_LOG +# define CVERBOSE_IF(writer, condition_, vlevel, dispatchAction, ...) if (VLOG_IS_ON(vlevel) && (condition_)) writer( \ + el::Level::Verbose, __FILE__, __LINE__, ELPP_FUNC, dispatchAction, vlevel).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) +#else +# define CVERBOSE_IF(writer, condition_, vlevel, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_VERBOSE_LOG +// Occasional logs +#if ELPP_INFO_LOG +# define CINFO_EVERY_N(writer, occasion, dispatchAction, ...)\ + ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Info, dispatchAction, __VA_ARGS__) +#else +# define CINFO_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_INFO_LOG +#if ELPP_WARNING_LOG +# define CWARNING_EVERY_N(writer, occasion, dispatchAction, ...)\ + ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Warning, dispatchAction, __VA_ARGS__) +#else +# define CWARNING_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_WARNING_LOG +#if ELPP_DEBUG_LOG +# define CDEBUG_EVERY_N(writer, occasion, dispatchAction, ...)\ + ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Debug, dispatchAction, __VA_ARGS__) +#else +# define CDEBUG_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_DEBUG_LOG +#if ELPP_ERROR_LOG +# define CERROR_EVERY_N(writer, occasion, dispatchAction, ...)\ + ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Error, dispatchAction, __VA_ARGS__) +#else +# define CERROR_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_ERROR_LOG +#if ELPP_FATAL_LOG +# define CFATAL_EVERY_N(writer, occasion, dispatchAction, ...)\ + ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Fatal, dispatchAction, __VA_ARGS__) +#else +# define CFATAL_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_FATAL_LOG +#if ELPP_TRACE_LOG +# define CTRACE_EVERY_N(writer, occasion, dispatchAction, ...)\ + ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Trace, dispatchAction, __VA_ARGS__) +#else +# define CTRACE_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_TRACE_LOG +#if ELPP_VERBOSE_LOG +# define CVERBOSE_EVERY_N(writer, occasion, vlevel, dispatchAction, ...)\ + CVERBOSE_IF(writer, ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion), vlevel, dispatchAction, __VA_ARGS__) +#else +# define CVERBOSE_EVERY_N(writer, occasion, vlevel, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_VERBOSE_LOG +// After N logs +#if ELPP_INFO_LOG +# define CINFO_AFTER_N(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__) +#else +# define CINFO_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_INFO_LOG +#if ELPP_WARNING_LOG +# define CWARNING_AFTER_N(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__) +#else +# define CWARNING_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_WARNING_LOG +#if ELPP_DEBUG_LOG +# define CDEBUG_AFTER_N(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__) +#else +# define CDEBUG_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_DEBUG_LOG +#if ELPP_ERROR_LOG +# define CERROR_AFTER_N(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__) +#else +# define CERROR_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_ERROR_LOG +#if ELPP_FATAL_LOG +# define CFATAL_AFTER_N(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__) +#else +# define CFATAL_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_FATAL_LOG +#if ELPP_TRACE_LOG +# define CTRACE_AFTER_N(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__) +#else +# define CTRACE_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_TRACE_LOG +#if ELPP_VERBOSE_LOG +# define CVERBOSE_AFTER_N(writer, n, vlevel, dispatchAction, ...)\ + CVERBOSE_IF(writer, ELPP->validateAfterNCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__) +#else +# define CVERBOSE_AFTER_N(writer, n, vlevel, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_VERBOSE_LOG +// N Times logs +#if ELPP_INFO_LOG +# define CINFO_N_TIMES(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__) +#else +# define CINFO_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_INFO_LOG +#if ELPP_WARNING_LOG +# define CWARNING_N_TIMES(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__) +#else +# define CWARNING_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_WARNING_LOG +#if ELPP_DEBUG_LOG +# define CDEBUG_N_TIMES(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__) +#else +# define CDEBUG_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_DEBUG_LOG +#if ELPP_ERROR_LOG +# define CERROR_N_TIMES(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__) +#else +# define CERROR_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_ERROR_LOG +#if ELPP_FATAL_LOG +# define CFATAL_N_TIMES(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__) +#else +# define CFATAL_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_FATAL_LOG +#if ELPP_TRACE_LOG +# define CTRACE_N_TIMES(writer, n, dispatchAction, ...)\ + ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__) +#else +# define CTRACE_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_TRACE_LOG +#if ELPP_VERBOSE_LOG +# define CVERBOSE_N_TIMES(writer, n, vlevel, dispatchAction, ...)\ + CVERBOSE_IF(writer, ELPP->validateNTimesCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__) +#else +# define CVERBOSE_N_TIMES(writer, n, vlevel, dispatchAction, ...) el::base::NullWriter() +#endif // ELPP_VERBOSE_LOG +// +// Custom Loggers - Requires (level, dispatchAction, loggerId/s) +// +// undef existing +#undef CLOG +#undef CLOG_VERBOSE +#undef CVLOG +#undef CLOG_IF +#undef CLOG_VERBOSE_IF +#undef CVLOG_IF +#undef CLOG_EVERY_N +#undef CVLOG_EVERY_N +#undef CLOG_AFTER_N +#undef CVLOG_AFTER_N +#undef CLOG_N_TIMES +#undef CVLOG_N_TIMES +// Normal logs +#define CLOG(LEVEL, ...)\ + C##LEVEL(el::base::Writer, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define CVLOG(vlevel, ...) CVERBOSE(el::base::Writer, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) +// Conditional logs +#define CLOG_IF(condition, LEVEL, ...)\ + C##LEVEL##_IF(el::base::Writer, condition, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define CVLOG_IF(condition, vlevel, ...)\ + CVERBOSE_IF(el::base::Writer, condition, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) +// Hit counts based logs +#define CLOG_EVERY_N(n, LEVEL, ...)\ + C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define CVLOG_EVERY_N(n, vlevel, ...)\ + CVERBOSE_EVERY_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define CLOG_AFTER_N(n, LEVEL, ...)\ + C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define CVLOG_AFTER_N(n, vlevel, ...)\ + CVERBOSE_AFTER_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define CLOG_N_TIMES(n, LEVEL, ...)\ + C##LEVEL##_N_TIMES(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define CVLOG_N_TIMES(n, vlevel, ...)\ + CVERBOSE_N_TIMES(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) +// +// Default Loggers macro using CLOG(), CLOG_VERBOSE() and CVLOG() macros +// +// undef existing +#undef LOG +#undef VLOG +#undef LOG_IF +#undef VLOG_IF +#undef LOG_EVERY_N +#undef VLOG_EVERY_N +#undef LOG_AFTER_N +#undef VLOG_AFTER_N +#undef LOG_N_TIMES +#undef VLOG_N_TIMES +#undef ELPP_CURR_FILE_LOGGER_ID +#if defined(ELPP_DEFAULT_LOGGER) +# define ELPP_CURR_FILE_LOGGER_ID ELPP_DEFAULT_LOGGER +#else +# define ELPP_CURR_FILE_LOGGER_ID el::base::consts::kDefaultLoggerId +#endif +#undef ELPP_TRACE +#define ELPP_TRACE CLOG(TRACE, ELPP_CURR_FILE_LOGGER_ID) +// Normal logs +#define LOG(LEVEL) CLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define VLOG(vlevel) CVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID) +// Conditional logs +#define LOG_IF(condition, LEVEL) CLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define VLOG_IF(condition, vlevel) CVLOG_IF(condition, vlevel, ELPP_CURR_FILE_LOGGER_ID) +// Hit counts based logs +#define LOG_EVERY_N(n, LEVEL) CLOG_EVERY_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define VLOG_EVERY_N(n, vlevel) CVLOG_EVERY_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) +#define LOG_AFTER_N(n, LEVEL) CLOG_AFTER_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define VLOG_AFTER_N(n, vlevel) CVLOG_AFTER_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) +#define LOG_N_TIMES(n, LEVEL) CLOG_N_TIMES(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define VLOG_N_TIMES(n, vlevel) CVLOG_N_TIMES(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) +// Generic PLOG() +#undef CPLOG +#undef CPLOG_IF +#undef PLOG +#undef PLOG_IF +#undef DCPLOG +#undef DCPLOG_IF +#undef DPLOG +#undef DPLOG_IF +#define CPLOG(LEVEL, ...)\ + C##LEVEL(el::base::PErrorWriter, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define CPLOG_IF(condition, LEVEL, ...)\ + C##LEVEL##_IF(el::base::PErrorWriter, condition, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define DCPLOG(LEVEL, ...)\ + if (ELPP_DEBUG_LOG) C##LEVEL(el::base::PErrorWriter, el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define DCPLOG_IF(condition, LEVEL, ...)\ + C##LEVEL##_IF(el::base::PErrorWriter, (ELPP_DEBUG_LOG) && (condition), el::base::DispatchAction::NormalLog, __VA_ARGS__) +#define PLOG(LEVEL) CPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define PLOG_IF(condition, LEVEL) CPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define DPLOG(LEVEL) DCPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define DPLOG_IF(condition, LEVEL) DCPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +// Generic SYSLOG() +#undef CSYSLOG +#undef CSYSLOG_IF +#undef CSYSLOG_EVERY_N +#undef CSYSLOG_AFTER_N +#undef CSYSLOG_N_TIMES +#undef SYSLOG +#undef SYSLOG_IF +#undef SYSLOG_EVERY_N +#undef SYSLOG_AFTER_N +#undef SYSLOG_N_TIMES +#undef DCSYSLOG +#undef DCSYSLOG_IF +#undef DCSYSLOG_EVERY_N +#undef DCSYSLOG_AFTER_N +#undef DCSYSLOG_N_TIMES +#undef DSYSLOG +#undef DSYSLOG_IF +#undef DSYSLOG_EVERY_N +#undef DSYSLOG_AFTER_N +#undef DSYSLOG_N_TIMES +#if defined(ELPP_SYSLOG) +# define CSYSLOG(LEVEL, ...)\ + C##LEVEL(el::base::Writer, el::base::DispatchAction::SysLog, __VA_ARGS__) +# define CSYSLOG_IF(condition, LEVEL, ...)\ + C##LEVEL##_IF(el::base::Writer, condition, el::base::DispatchAction::SysLog, __VA_ARGS__) +# define CSYSLOG_EVERY_N(n, LEVEL, ...) C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) +# define CSYSLOG_AFTER_N(n, LEVEL, ...) C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) +# define CSYSLOG_N_TIMES(n, LEVEL, ...) C##LEVEL##_N_TIMES(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) +# define SYSLOG(LEVEL) CSYSLOG(LEVEL, el::base::consts::kSysLogLoggerId) +# define SYSLOG_IF(condition, LEVEL) CSYSLOG_IF(condition, LEVEL, el::base::consts::kSysLogLoggerId) +# define SYSLOG_EVERY_N(n, LEVEL) CSYSLOG_EVERY_N(n, LEVEL, el::base::consts::kSysLogLoggerId) +# define SYSLOG_AFTER_N(n, LEVEL) CSYSLOG_AFTER_N(n, LEVEL, el::base::consts::kSysLogLoggerId) +# define SYSLOG_N_TIMES(n, LEVEL) CSYSLOG_N_TIMES(n, LEVEL, el::base::consts::kSysLogLoggerId) +# define DCSYSLOG(LEVEL, ...) if (ELPP_DEBUG_LOG) C##LEVEL(el::base::Writer, el::base::DispatchAction::SysLog, __VA_ARGS__) +# define DCSYSLOG_IF(condition, LEVEL, ...)\ + C##LEVEL##_IF(el::base::Writer, (ELPP_DEBUG_LOG) && (condition), el::base::DispatchAction::SysLog, __VA_ARGS__) +# define DCSYSLOG_EVERY_N(n, LEVEL, ...)\ + if (ELPP_DEBUG_LOG) C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) +# define DCSYSLOG_AFTER_N(n, LEVEL, ...)\ + if (ELPP_DEBUG_LOG) C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) +# define DCSYSLOG_N_TIMES(n, LEVEL, ...)\ + if (ELPP_DEBUG_LOG) C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) +# define DSYSLOG(LEVEL) DCSYSLOG(LEVEL, el::base::consts::kSysLogLoggerId) +# define DSYSLOG_IF(condition, LEVEL) DCSYSLOG_IF(condition, LEVEL, el::base::consts::kSysLogLoggerId) +# define DSYSLOG_EVERY_N(n, LEVEL) DCSYSLOG_EVERY_N(n, LEVEL, el::base::consts::kSysLogLoggerId) +# define DSYSLOG_AFTER_N(n, LEVEL) DCSYSLOG_AFTER_N(n, LEVEL, el::base::consts::kSysLogLoggerId) +# define DSYSLOG_N_TIMES(n, LEVEL) DCSYSLOG_N_TIMES(n, LEVEL, el::base::consts::kSysLogLoggerId) +#else +# define CSYSLOG(LEVEL, ...) el::base::NullWriter() +# define CSYSLOG_IF(condition, LEVEL, ...) el::base::NullWriter() +# define CSYSLOG_EVERY_N(n, LEVEL, ...) el::base::NullWriter() +# define CSYSLOG_AFTER_N(n, LEVEL, ...) el::base::NullWriter() +# define CSYSLOG_N_TIMES(n, LEVEL, ...) el::base::NullWriter() +# define SYSLOG(LEVEL) el::base::NullWriter() +# define SYSLOG_IF(condition, LEVEL) el::base::NullWriter() +# define SYSLOG_EVERY_N(n, LEVEL) el::base::NullWriter() +# define SYSLOG_AFTER_N(n, LEVEL) el::base::NullWriter() +# define SYSLOG_N_TIMES(n, LEVEL) el::base::NullWriter() +# define DCSYSLOG(LEVEL, ...) el::base::NullWriter() +# define DCSYSLOG_IF(condition, LEVEL, ...) el::base::NullWriter() +# define DCSYSLOG_EVERY_N(n, LEVEL, ...) el::base::NullWriter() +# define DCSYSLOG_AFTER_N(n, LEVEL, ...) el::base::NullWriter() +# define DCSYSLOG_N_TIMES(n, LEVEL, ...) el::base::NullWriter() +# define DSYSLOG(LEVEL) el::base::NullWriter() +# define DSYSLOG_IF(condition, LEVEL) el::base::NullWriter() +# define DSYSLOG_EVERY_N(n, LEVEL) el::base::NullWriter() +# define DSYSLOG_AFTER_N(n, LEVEL) el::base::NullWriter() +# define DSYSLOG_N_TIMES(n, LEVEL) el::base::NullWriter() +#endif // defined(ELPP_SYSLOG) +// +// Custom Debug Only Loggers - Requires (level, loggerId/s) +// +// undef existing +#undef DCLOG +#undef DCVLOG +#undef DCLOG_IF +#undef DCVLOG_IF +#undef DCLOG_EVERY_N +#undef DCVLOG_EVERY_N +#undef DCLOG_AFTER_N +#undef DCVLOG_AFTER_N +#undef DCLOG_N_TIMES +#undef DCVLOG_N_TIMES +// Normal logs +#define DCLOG(LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG(LEVEL, __VA_ARGS__) +#define DCLOG_VERBOSE(vlevel, ...) if (ELPP_DEBUG_LOG) CLOG_VERBOSE(vlevel, __VA_ARGS__) +#define DCVLOG(vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG(vlevel, __VA_ARGS__) +// Conditional logs +#define DCLOG_IF(condition, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_IF(condition, LEVEL, __VA_ARGS__) +#define DCVLOG_IF(condition, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_IF(condition, vlevel, __VA_ARGS__) +// Hit counts based logs +#define DCLOG_EVERY_N(n, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_EVERY_N(n, LEVEL, __VA_ARGS__) +#define DCVLOG_EVERY_N(n, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_EVERY_N(n, vlevel, __VA_ARGS__) +#define DCLOG_AFTER_N(n, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_AFTER_N(n, LEVEL, __VA_ARGS__) +#define DCVLOG_AFTER_N(n, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_AFTER_N(n, vlevel, __VA_ARGS__) +#define DCLOG_N_TIMES(n, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_N_TIMES(n, LEVEL, __VA_ARGS__) +#define DCVLOG_N_TIMES(n, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_N_TIMES(n, vlevel, __VA_ARGS__) +// +// Default Debug Only Loggers macro using CLOG(), CLOG_VERBOSE() and CVLOG() macros +// +// undef existing +#undef DLOG +#undef DVLOG +#undef DLOG_IF +#undef DVLOG_IF +#undef DLOG_EVERY_N +#undef DVLOG_EVERY_N +#undef DLOG_AFTER_N +#undef DVLOG_AFTER_N +#undef DLOG_N_TIMES +#undef DVLOG_N_TIMES +// Normal logs +#define DLOG(LEVEL) DCLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define DVLOG(vlevel) DCVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID) +// Conditional logs +#define DLOG_IF(condition, LEVEL) DCLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define DVLOG_IF(condition, vlevel) DCVLOG_IF(condition, vlevel, ELPP_CURR_FILE_LOGGER_ID) +// Hit counts based logs +#define DLOG_EVERY_N(n, LEVEL) DCLOG_EVERY_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define DVLOG_EVERY_N(n, vlevel) DCVLOG_EVERY_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) +#define DLOG_AFTER_N(n, LEVEL) DCLOG_AFTER_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define DVLOG_AFTER_N(n, vlevel) DCVLOG_AFTER_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) +#define DLOG_N_TIMES(n, LEVEL) DCLOG_N_TIMES(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) +#define DVLOG_N_TIMES(n, vlevel) DCVLOG_N_TIMES(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) +// Check macros +#undef CCHECK +#undef CPCHECK +#undef CCHECK_EQ +#undef CCHECK_NE +#undef CCHECK_LT +#undef CCHECK_GT +#undef CCHECK_LE +#undef CCHECK_GE +#undef CCHECK_BOUNDS +#undef CCHECK_NOTNULL +#undef CCHECK_STRCASEEQ +#undef CCHECK_STRCASENE +#undef CHECK +#undef PCHECK +#undef CHECK_EQ +#undef CHECK_NE +#undef CHECK_LT +#undef CHECK_GT +#undef CHECK_LE +#undef CHECK_GE +#undef CHECK_BOUNDS +#undef CHECK_NOTNULL +#undef CHECK_STRCASEEQ +#undef CHECK_STRCASENE +#define CCHECK(condition, ...) CLOG_IF(!(condition), FATAL, __VA_ARGS__) << "Check failed: [" << #condition << "] " +#define CPCHECK(condition, ...) CPLOG_IF(!(condition), FATAL, __VA_ARGS__) << "Check failed: [" << #condition << "] " +#define CHECK(condition) CCHECK(condition, ELPP_CURR_FILE_LOGGER_ID) +#define PCHECK(condition) CPCHECK(condition, ELPP_CURR_FILE_LOGGER_ID) +#define CCHECK_EQ(a, b, ...) CCHECK(a == b, __VA_ARGS__) +#define CCHECK_NE(a, b, ...) CCHECK(a != b, __VA_ARGS__) +#define CCHECK_LT(a, b, ...) CCHECK(a < b, __VA_ARGS__) +#define CCHECK_GT(a, b, ...) CCHECK(a > b, __VA_ARGS__) +#define CCHECK_LE(a, b, ...) CCHECK(a <= b, __VA_ARGS__) +#define CCHECK_GE(a, b, ...) CCHECK(a >= b, __VA_ARGS__) +#define CCHECK_BOUNDS(val, min, max, ...) CCHECK(val >= min && val <= max, __VA_ARGS__) +#define CHECK_EQ(a, b) CCHECK_EQ(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_NE(a, b) CCHECK_NE(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_LT(a, b) CCHECK_LT(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_GT(a, b) CCHECK_GT(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_LE(a, b) CCHECK_LE(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_GE(a, b) CCHECK_GE(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_BOUNDS(val, min, max) CCHECK_BOUNDS(val, min, max, ELPP_CURR_FILE_LOGGER_ID) +namespace el { +namespace base { +namespace utils { +template +static T* checkNotNull(T* ptr, const char* name, const char* loggers, ...) { + CLOG_IF(ptr == nullptr, FATAL, loggers) << "Check failed: [" << name << " != nullptr]"; + return ptr; +} +} // namespace utils +} // namespace base +} // namespace el +#define CCHECK_NOTNULL(ptr, ...) el::base::utils::checkNotNull(ptr, #ptr, __VA_ARGS__) +#define CCHECK_STREQ(str1, str2, ...) CLOG_IF(!el::base::utils::Str::cStringEq(str1, str2), FATAL, __VA_ARGS__) \ + << "Check failed: [" << #str1 << " == " << #str2 << "] " +#define CCHECK_STRNE(str1, str2, ...) CLOG_IF(el::base::utils::Str::cStringEq(str1, str2), FATAL, __VA_ARGS__) \ + << "Check failed: [" << #str1 << " != " << #str2 << "] " +#define CCHECK_STRCASEEQ(str1, str2, ...) CLOG_IF(!el::base::utils::Str::cStringCaseEq(str1, str2), FATAL, __VA_ARGS__) \ + << "Check failed: [" << #str1 << " == " << #str2 << "] " +#define CCHECK_STRCASENE(str1, str2, ...) CLOG_IF(el::base::utils::Str::cStringCaseEq(str1, str2), FATAL, __VA_ARGS__) \ + << "Check failed: [" << #str1 << " != " << #str2 << "] " +#define CHECK_NOTNULL(ptr) CCHECK_NOTNULL(ptr, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_STREQ(str1, str2) CCHECK_STREQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_STRNE(str1, str2) CCHECK_STRNE(str1, str2, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_STRCASEEQ(str1, str2) CCHECK_STRCASEEQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID) +#define CHECK_STRCASENE(str1, str2) CCHECK_STRCASENE(str1, str2, ELPP_CURR_FILE_LOGGER_ID) +#undef DCCHECK +#undef DCCHECK_EQ +#undef DCCHECK_NE +#undef DCCHECK_LT +#undef DCCHECK_GT +#undef DCCHECK_LE +#undef DCCHECK_GE +#undef DCCHECK_BOUNDS +#undef DCCHECK_NOTNULL +#undef DCCHECK_STRCASEEQ +#undef DCCHECK_STRCASENE +#undef DCPCHECK +#undef DCHECK +#undef DCHECK_EQ +#undef DCHECK_NE +#undef DCHECK_LT +#undef DCHECK_GT +#undef DCHECK_LE +#undef DCHECK_GE +#undef DCHECK_BOUNDS_ +#undef DCHECK_NOTNULL +#undef DCHECK_STRCASEEQ +#undef DCHECK_STRCASENE +#undef DPCHECK +#define DCCHECK(condition, ...) if (ELPP_DEBUG_LOG) CCHECK(condition, __VA_ARGS__) +#define DCCHECK_EQ(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_EQ(a, b, __VA_ARGS__) +#define DCCHECK_NE(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_NE(a, b, __VA_ARGS__) +#define DCCHECK_LT(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_LT(a, b, __VA_ARGS__) +#define DCCHECK_GT(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_GT(a, b, __VA_ARGS__) +#define DCCHECK_LE(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_LE(a, b, __VA_ARGS__) +#define DCCHECK_GE(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_GE(a, b, __VA_ARGS__) +#define DCCHECK_BOUNDS(val, min, max, ...) if (ELPP_DEBUG_LOG) CCHECK_BOUNDS(val, min, max, __VA_ARGS__) +#define DCCHECK_NOTNULL(ptr, ...) if (ELPP_DEBUG_LOG) CCHECK_NOTNULL(ptr, __VA_ARGS__) +#define DCCHECK_STREQ(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STREQ(str1, str2, __VA_ARGS__) +#define DCCHECK_STRNE(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STRNE(str1, str2, __VA_ARGS__) +#define DCCHECK_STRCASEEQ(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STRCASEEQ(str1, str2, __VA_ARGS__) +#define DCCHECK_STRCASENE(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STRCASENE(str1, str2, __VA_ARGS__) +#define DCPCHECK(condition, ...) if (ELPP_DEBUG_LOG) CPCHECK(condition, __VA_ARGS__) +#define DCHECK(condition) DCCHECK(condition, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_EQ(a, b) DCCHECK_EQ(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_NE(a, b) DCCHECK_NE(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_LT(a, b) DCCHECK_LT(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_GT(a, b) DCCHECK_GT(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_LE(a, b) DCCHECK_LE(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_GE(a, b) DCCHECK_GE(a, b, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_BOUNDS(val, min, max) DCCHECK_BOUNDS(val, min, max, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_NOTNULL(ptr) DCCHECK_NOTNULL(ptr, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_STREQ(str1, str2) DCCHECK_STREQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_STRNE(str1, str2) DCCHECK_STRNE(str1, str2, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_STRCASEEQ(str1, str2) DCCHECK_STRCASEEQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID) +#define DCHECK_STRCASENE(str1, str2) DCCHECK_STRCASENE(str1, str2, ELPP_CURR_FILE_LOGGER_ID) +#define DPCHECK(condition) DCPCHECK(condition, ELPP_CURR_FILE_LOGGER_ID) +#if defined(ELPP_DISABLE_DEFAULT_CRASH_HANDLING) +# define ELPP_USE_DEF_CRASH_HANDLER false +#else +# define ELPP_USE_DEF_CRASH_HANDLER true +#endif // defined(ELPP_DISABLE_DEFAULT_CRASH_HANDLING) +#define ELPP_CRASH_HANDLER_INIT +#define ELPP_INIT_EASYLOGGINGPP(val)\ + ELPP_INITI_BASIC_DECLR\ + namespace el {\ + namespace base {\ + el::base::type::StoragePointer elStorage(val);\ + }\ + el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\ + } + +#if ELPP_ASYNC_LOGGING +# define INITIALIZE_EASYLOGGINGPP\ + ELPP_INIT_EASYLOGGINGPP(new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder()),\ + new el::base::AsyncDispatchWorker()))\ + +#else +# define INITIALIZE_EASYLOGGINGPP\ + ELPP_INIT_EASYLOGGINGPP(new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder()))) +#endif // ELPP_ASYNC_LOGGING +#define INITIALIZE_NULL_EASYLOGGINGPP\ + ELPP_INITI_BASIC_DECLR\ + namespace el {\ + namespace base {\ + el::base::type::StoragePointer elStorage;\ + }\ + el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\ + } +// NOTE: no ELPP_INITI_BASIC_DECLR when sharing - causes double free corruption on external symbols +#define SHARE_EASYLOGGINGPP(initializedStorage)\ + namespace el {\ + namespace base {\ + el::base::type::StoragePointer elStorage(initializedStorage);\ + }\ + el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\ + } + +#if defined(ELPP_UNICODE) +# define START_EASYLOGGINGPP(argc, argv) el::Helpers::setArgs(argc, argv); std::locale::global(std::locale("")) +#else +# define START_EASYLOGGINGPP(argc, argv) el::Helpers::setArgs(argc, argv) +#endif // defined(ELPP_UNICODE) +#endif // EASYLOGGINGPP_H diff --git a/src/logging.hpp b/src/logging.hpp index 58167f9..e5d8457 100644 --- a/src/logging.hpp +++ b/src/logging.hpp @@ -1,21 +1,26 @@ -#include +#include #ifndef __LOGGING_HPP__ #define __LOGGING_HPP__ namespace csio { +#define INIT_LOGGING INITIALIZE_EASYLOGGINGPP + +using namespace el; + inline void InitLogging(int verbose_level = 1) { - verbose_level = (verbose_level < 4 ? verbose_level : 1); - FLAGS_logtostderr = true; -#ifdef NDEBUG - FLAGS_log_prefix = false; -#else - FLAGS_log_prefix = true; -#endif // _NDEBUG - FLAGS_v = verbose_level; - google::InitGoogleLogging("dzip"); + Loggers::setVerboseLevel(verbose_level < 4 ? verbose_level : 1); +// verbose_level = ; +// FLAGS_logtostderr = true; +//#ifdef NDEBUG +// FLAGS_log_prefix = false; +//#else +// FLAGS_log_prefix = true; +//#endif // _NDEBUG +// FLAGS_v = verbose_level; +// google::InitGoogleLogging("dzip"); } } // namespace diff --git a/third-party/glog-0.3.3.tar.gz b/third-party/glog-0.3.3.tar.gz deleted file mode 100644 index 92fa52d296fea2884bd58d6010b0f869611999f7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 509676 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 z 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

O)Z*6l>N(5oaKgq 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

RPV(Ci=fL`} z(T4G$_VZ7B$FGm~0vLmRd{BG))80?8vbHy99CwlObX98k^7Y{pVA9>o)pd--_@cgV z+lO}dbT9yBTm9wyWqM4I-+I%6iUpX&l{$ZM(MS16%aQHtOiR5f(k^p>}a? zb?6RH2On)p^kGw_$pFtd8_i?~sZH1bjf;bhy>|g8C2oK&{D=F%Yyq;JZXq~E zCem-j;!)icPDDnsiRE{iu*X-2{RS*yvj@`O;l@S>YY+RnPM=Eq^jjZ)>&tH>69F&x z8n~SrN(wrqWBKq&J#a_P6LP9;d`G`*Y|wA?l{8Y=yQ)D2*gmd9)8v(@t#vQy2(`)A z0GI3s8wxJqE@;qtoA9TB1XkPVHHu1uZljAC1;eussgoKVX5acJxdnSiO+c z9W0#LSYhlbTU|V9;~K7?!mR?Z%VirIR0z|DQm*||JF2adGnf}$+rLlTiQ7D0eMYi~ zP5NgWgM+y8-~(&fj$pP>(u5t2WLAUm*4DUz0uzXf|36 z;?g&dYfm^ZiG4~h|6v5!VCKL3~ z(9h=CW{G*z~{&!|&u@ygTSY zjER-urC@B9hf>V9ou6uNQBX-;Z}7tj9=s>(z~LgOQ=OyEYF-_@PPN1I2jFV^-ukK% z0$F4r0k9L_TbE__<3TGqg2z-G452hGd>DliRz}$raxC;Yt7Y5)i48UC&02KzHjt-J-5T}QZd^r|2WjeO8=Q&8( zXWj0?0=~AP7syV5T)#4r0F*;K8VMNRCnMlmJ^7ALS;~TtKL8i|G}Zfi4zFr4IR8WZ z;H;%36`N8*B0E<$d#y=9?B^B-ouyws@vLnpfcxy`0vkGMrGj>l9@6chSVGQgpU@oa z7i!R09EOwFGgsAMV;_45PpFYUrU!sX9P(%as^SjtPjqTsnsk-_pFjRRVUA~?w07*n zBfHh8w~r3VHYg76iyeqr9X;^^g54g)o+MjpTz8nQH^3I!3|(8Ag;XK*CA_^$C->RJ z2^<&|hvBC$lsAMBu^hMqdNNK07?Ui($uQ$I3{0try=WU|x=C2E6%CrH;C#oE(}CBe zfXK;@MQx`H<7se=LGj>)RqCdLopIIdS|!#YkuEYlP#qTb6M5Filu{#>=xzo!*$8(p zZ%DJ~%B?~H(V+dJ&L+SE%ydA9V*g-!1ZFxCk z_sCUvv%TYA*n9Nx2kclm@vD);q?*UYNjDBy8jpdy-`WzGddrqfmjj}DG!Z)5W790t z!zE`+u)Xm$T1klww;5FyWYR(Ct53>BmT-HVR$zRGT?h^Z| z-7~2vF(>xYG1mw&K!wJ-Q1TEn?8vUq#_Pf~DGg6zpal@4U?v0{09JJT)Dg_XQ}+J z>rbAp-`)TJuKWM`-Npaz;(vGXzq|O~UHt!JFaBQ|-!E*MSn(y2EV(DgCXRs~02gSaRe0_rj3gDiz z1gO?AB^nAFI#kv>t_GDpSOLPREF_>R{Mq#JU1~TVc!4b2etCGZW82ur39aeNot@ak zd&7(i=2!y*2QRHBg{47wM{o>IhJ(bN{j*7gR?EOwLHN0}NlhWo* zpmg5MYDufRhE6xYIEG^f12Rxjt-@q9^e@mLw!m^>(H}doyKu7rMU~1TSve#Timzfw z#3mW}E|B;fo~<<*qtt@lRZ8MQpq%DWWD_qc$3E^OpL>nPHf*y9GhDQU6tI8jj*g0T zxUkjA)_P^VQZ138^hZjnp)x=^Ax3aw{FA?>Yy!z#EcCk|KI=&`j%gKB>caV<$#uW} zqOo6;DVFA3N~ylVL~GklIJ9l}S9$5%cCk=^WlXKp%WjvaM?zsZh7%}e9kgP@$sqE^ z7;ocz0@E*R(U*Q-h$96^x&vd11QSsM%YW?zZoPW|z0i=S7A|Q;j z`{e27tTmXA?-Ne)+ReqcvaRFbCt8>TLRkJff8cu0zSKlaEjL0Lvl%u=+8JAT8z2rj zSy?36gedxm$G)K5t!*HtxCKkEw5IeRmT&>z>cK9pGh5$Qqq3y17R{} z59f?iHZ^VMvXur^Wl;G<9WNS=b6VI_J*%=+rON8C;Cmq4Y999F37lR~!U`P_2+|;k zmzZPfUvST>C8>l9bsr`D)K-&dsd?913V=(ydx_0lL&_nil=tG3q$Z$8a_gbz2Xv)H zrFgEX)AM0y$>}JgqFAUZDr#y7X#y>goVuYPJW736;|W|>LX?Eb@T&P^O(|1+xLq$M4i7aFPGxAPVwFukky*aiKn&C#?#uocv_o{ zr`2zRr}g4*Uk^*GpN*yUd9k!Q8%t~721{#S6HB$v#?q5{u~eIlrS)%vrPZ&AB@;3@WmV9ILk_Up-4-NDh~QS@XsPYqyXoJ4OKP>5w>IDZXq)} zR7NZqa@ujd-BxFz8QoT{oqAwA4zrb29QkIrpl~wAxO1gEXfxu1|GU_KaFk~<`#Arq zrV-QaKh~eDKU+)Lf2_h!clIBDm;J{NclIB5_8)ilA9wa2clIB5jvrIyvDv2Q`Etb&~8}-H%Pqd-~pNsxE z1!@ixmM;2(q)b@c=(piGS*8+88bw2AoM^=n3zD`lsG>4U*!6z9LH}hISdEMfu zsM(OXVhDtL3JyJ#(k5haK-N@(TQ%F{}-{~01G#A=n z?bePBT>c$;Z4@e%l}d%DjA;*4C~mW23Fr=vW=e-)mK$a^%EJqWuWZKV>%E|Hv>=H) zdDV(I1sibK^MZ0>3CmUi{#6m<$wv!55pN0cUY7#~Zbt;h>^~iVxzHxTav3UGf$zg5 zcjUS~7G_{>Jq}~5kZa?X!Y+*-DdQ-tp?&I(y5~bD_*iCtCm3US3jta3i5XVJO6ZM^ zSlfWX=@bTLu&`8=ZES^FjwM!eEMZ#GPdVvsNoF0QLOgJnPyG=lwd65i)}z2-tCI=b zY~ln)Z$XIa*qzo%17mmhN^?9tf8Hy0Y-Dkddz#y_LYW-&MUxUrx;lRGvHFxcZbNcT zTK5U~W}>Bwneb|*&A-AnA^i-VM)h8OzpZg?qF6Qo=OyK--$yLmr#?5oXmP)tA<9jQ-}s+mVj1HV-r7p6 zaJu1PV_L&|vm3tbOl!D3v)%sGcF&XTG9#@YQo7+=;q1$()Syl;962NE|65QcLw^{S zm@LVeFa_cBsqxFH@FwbO9`60EO9O|{H(VNo{%^Z9yGJK4KnO_lhrfr%D;ED;IJ~t? znd54hdPzQQt51*lQ({f$=kZ%xX&$fH`&U}Jzn;gpJFVL<t% zMW<|?mgetW9AHqwx9{I~?%#*MPj6fp#z3+WY7&gWR^kxfk6M!vnZ)asX67vTNKN

&+sL96a6XfCBDF&70Vw#_9A6K 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 W`uqPjdSm;5M6$c9#30 Date: Wed, 22 Jun 2016 09:12:47 +0300 Subject: [PATCH 4/5] ENH: pthreads->stdthreads to simplify dependencies --- CMakeLists.txt | 5 +---- conanfile.py | 5 +++-- src/logging.hpp | 2 ++ 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index dd4f8ff..3b4fea8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -95,10 +95,7 @@ if(WITH_dzip) endif() find_package(Threads REQUIRED) - if (NOT CMAKE_USE_PTHREADS_INIT) - message(FATAL_ERROR "dzip utility needs pthreads") - endif() - list(APPEND LIBRARIES pthread rt) + list(APPEND LIBRARIES ${CMAKE_THREAD_LIBS_INIT}) add_library(dzip_internal STATIC ./src/ProcessManagerBase.hpp diff --git a/conanfile.py b/conanfile.py index d06f399..2815df7 100644 --- a/conanfile.py +++ b/conanfile.py @@ -6,7 +6,7 @@ class SnappyStreamConan(ConanFile): requires = "" settings = "os", "compiler", "build_type", "arch" options = {"shared": [True, False], "dzip": [True, False]} - default_options = "shared=False", "dzip=False", "glog:shared=False", "zlib:shared=False", "libzmq:shared=False" + default_options = "shared=False", "dzip=False", "zlib:shared=False", "libzmq:shared=False" generators = "cmake" exports = "*" @@ -14,7 +14,6 @@ def requirements(self): if self.options.dzip: self.requires("zlib/1.2.8@lasote/stable") self.requires("libzmq/4.1.5@memsharded/stable") - self.requires("glog/0.3.4@dwerner/testing") else: self.requires("zlib/1.2.8@lasote/stable") @@ -36,6 +35,8 @@ def package(self): self.copy("dzip", dst="bin", src="distr/bin") self.copy("*.h", dst="include", src="distr/include") self.copy("*.a", dst="lib", src="distr/lib") + self.copy("*.lib", dst="lib", src="distr/lib") + self.copy("*.dll", dst="lib", src="distr/lib") def package_info(self): self.cpp_info.libs = ["csio"] diff --git a/src/logging.hpp b/src/logging.hpp index e5d8457..ba2be56 100644 --- a/src/logging.hpp +++ b/src/logging.hpp @@ -5,6 +5,8 @@ namespace csio { +#define ELPP_THREAD_SAFE +#define ELPP_FORCE_USE_STD_THREAD #define INIT_LOGGING INITIALIZE_EASYLOGGINGPP using namespace el; From b146168117f591949890525c25fd84e497b3f156 Mon Sep 17 00:00:00 2001 From: hoxnox Date: Wed, 22 Jun 2016 09:25:12 +0300 Subject: [PATCH 5/5] version 0.1.3 --- CMakeLists.txt | 2 +- cmake/Modules/FindGlog.cmake | 51 ------------------------------------ conanfile.py | 11 ++++++-- test_package/conanfile.py | 2 +- 4 files changed, 11 insertions(+), 55 deletions(-) delete mode 100644 cmake/Modules/FindGlog.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index 3b4fea8..6d0ed29 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,7 +29,7 @@ nx_configure() set(csio_VERSION_MAJOR 0) set(csio_VERSION_MINOR 1) -set(csio_VERSION_PATCH 2) +set(csio_VERSION_PATCH 3) # configuration header set(TEST_SAMPLES_DIR "${PROJECT_SOURCE_DIR}/test/samples/") set(TEST_TMP_DIR "/tmp") diff --git a/cmake/Modules/FindGlog.cmake b/cmake/Modules/FindGlog.cmake deleted file mode 100644 index 83f7188..0000000 --- a/cmake/Modules/FindGlog.cmake +++ /dev/null @@ -1,51 +0,0 @@ -# Find Snappy -# Merder Kim -# -# input: -# Glog_ROOT -# Glog_USE_STATIC_LIBS -# -# output: -# Glog_FOUND -# Glog_INCLUDE_DIR -# Glog_LIBRARIES -# - -if(Glog_INCLUDE_DIR AND Glog_LIBRARIES) - set(Glog_FIND_QUITELY TRUE) # cached -endif(Glog_INCLUDE_DIR AND Glog_LIBRARIES) - -if(NOT DEFINED Glog_ROOT) - set(Glog_ROOT /usr /usr/local $ENV{Glog_ROOT}) -endif(NOT DEFINED Glog_ROOT) - -find_path(Glog_INCLUDE_DIR glog/logging.h - PATHS ${Glog_ROOT} - PATH_SUFFIXES include -) - -if(Glog_USE_STATIC_LIBS) - set( _glog_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) - if(WIN32) - set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) - else() - set(CMAKE_FIND_LIBRARY_SUFFIXES .a ) - endif() -endif() - -find_library(Glog_LIBRARIES - NAMES glog - PATHS ${Glog_ROOT} - PATH_SUFFIXES lib -) -mark_as_advanced(Glog_INCLUDE_DIR Glog_LIBRARIES) - -# Restore the original find library ordering -if( Glog_USE_STATIC_LIBS ) - set(CMAKE_FIND_LIBRARY_SUFFIXES ${_glog_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES}) -endif() - -include("${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake") -FIND_PACKAGE_HANDLE_STANDARD_ARGS(Glog DEFAULT_MSG Glog_INCLUDE_DIR Glog_LIBRARIES) - - diff --git a/conanfile.py b/conanfile.py index 2815df7..dcfbf1c 100644 --- a/conanfile.py +++ b/conanfile.py @@ -2,13 +2,20 @@ class SnappyStreamConan(ConanFile): name = "csio" - version = "0.1.2" + version = "0.1.3" requires = "" settings = "os", "compiler", "build_type", "arch" options = {"shared": [True, False], "dzip": [True, False]} default_options = "shared=False", "dzip=False", "zlib:shared=False", "libzmq:shared=False" generators = "cmake" - exports = "*" + exports = ("include/*.h", + "src/*.h", "src/*.c", + "src/*.hpp", "src/*.cpp", + "src/csio_config.cfg", + "cmake/ext/nx_utils.cmake", + "CMakeLists.txt", + "README.markdown", + "LICENSE") def requirements(self): if self.options.dzip: diff --git a/test_package/conanfile.py b/test_package/conanfile.py index 7a48ff9..d4ff662 100644 --- a/test_package/conanfile.py +++ b/test_package/conanfile.py @@ -6,7 +6,7 @@ class SnappyStreamTestConan(ConanFile): settings = "os", "compiler", "build_type", "arch" - requires = "csio/0.1.2@%s/%s" % (username, channel) + requires = "csio/0.1.3@%s/%s" % (username, channel) default_options = "csio:dzip=True" generators = "cmake"