easylogging++.h File Reference

#include "ea_config.h"
#include <climits>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include <cwchar>
#include <csignal>
#include <cerrno>
#include <cstdarg>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <utility>
#include <functional>
#include <algorithm>
#include <fstream>
#include <iostream>
#include <sstream>
#include <memory>
#include <type_traits>

Include dependency graph for easylogging++.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	el::Callback< T >
class	el::base::NoCopy
	Internal helper class that prevent copy constructor for class. More...
class	el::base::StaticClass
	Internal helper class that makes all default constructors private. More...
struct	std::hash< el::Level >
class	el::LevelHelper
	Static class that contains helper functions for el::Level. More...
class	el::ConfigurationTypeHelper
	Static class that contains helper functions for el::ConfigurationType. More...
class	el::base::SubsecondPrecision
	A subsecond precision class containing actual width and offset of the subsecond part. More...
class	el::base::threading::internal::Mutex
	A mutex wrapper for compiler that dont yet support std::recursive_mutex. More...
class	el::base::threading::internal::ScopedLock< M >
	Scoped lock for compiler that dont yet support std::lock_guard. More...
class	el::base::threading::ThreadSafe
	Base of thread safe class, this class is inheritable-only. More...
class	el::base::utils::File
class	el::base::utils::Str
	String utilities helper class used internally. You should not use it. More...
class	el::base::utils::OS
	Operating System helper static class used internally. You should not use it. More...
class	el::base::utils::DateTime
	Contains utilities for cross-platform date/time. This class make use of el::base::utils::Str. More...
class	el::base::utils::CommandLineArgs
	Command line arguments for application if specified using el::Helpers::setArgs(..) or START_EASYLOGGINGPP(..) More...
class	el::base::utils::AbstractRegistry< T_Ptr, Container >
	Abstract registry (aka repository) that provides basic interface for pointer repository specified by T_Ptr type. More...
class	el::base::utils::Registry< T_Ptr, T_Key >
	A pointer registry mechanism to manage memory and provide search functionalities. (non-predicate version) More...
class	el::base::utils::RegistryWithPred< T_Ptr, Pred >
	A pointer registry mechanism to manage memory and provide search functionalities. (predicate version) More...
class	el::base::utils::Utils
class	el::Loggable
	Base of Easylogging++ friendly class. More...
class	el::base::LogFormat
	Represents log format containing flags and date format. This is used internally to start initial log. More...
class	el::CustomFormatSpecifier
	User-provided custom format specifier. More...
class	el::Configuration
	Represents single configuration that has representing level, configuration type and a string based value. More...
class	el::Configuration::Predicate
	Used to find configuration from configuration (pointers) repository. Avoid using it. More...
class	el::Configurations
	Thread-safe Configuration repository. More...
class	el::Configurations::Parser
	Parser used internally to parse configurations from file or text. More...
class	el::base::TypedConfigurations
	Configurations with data types. More...
class	el::base::HitCounter
	Class that keeps record of current line hit for occasional logging. More...
class	el::base::HitCounter::Predicate
class	el::base::RegisteredHitCounters
	Repository for hit counters used across the application. More...
class	el::Callback< T >
class	el::LogDispatchData
class	el::LogDispatchCallback
class	el::PerformanceTrackingCallback
class	el::LoggerRegistrationCallback
class	el::LogBuilder
class	el::Logger
	Represents a logger holding ID and configurations we need to write logs. More...
class	el::base::RegisteredLoggers
	Loggers repository. More...
class	el::base::VRegistry
	Represents registries for verbose logging. More...
class	el::LogMessage
class	el::base::Storage
	Easylogging++ management storage. More...
class	el::base::DefaultLogDispatchCallback
class	el::base::DefaultLogBuilder
class	el::base::LogDispatcher
	Dispatches log messages. More...
class	el::base::MessageBuilder
class	el::base::NullWriter
	Writes nothing - Used when certain log is disabled. More...
class	el::base::Writer
	Main entry point of each logging. More...
class	el::base::PErrorWriter
class	el::base::debug::CrashHandler
class	el::SysLogInitializer
	Initializes syslog with process ID, options and facility. calls closelog() on d'tor. More...
class	el::Helpers
	Static helpers for developers. More...
class	el::Loggers
	Static helpers to deal with loggers and their configurations. More...
class	el::Loggers::ScopedAddFlag
	Adds flag and removes it when scope goes out. More...
class	el::Loggers::ScopedRemoveFlag
	Removes flag and add it when scope goes out. More...
class	el::VersionInfo

Namespaces
	el
	Easylogging++ entry namespace.
	el::base
	Namespace containing base/internal functionality used by Easylogging++.
	el::base::type
	Data types used by Easylogging++.
	std
	el::base::consts
	Namespace containing constants used internally.
	el::base::utils
	Namespace containing utility functions/static classes used internally.
	el::base::utils::bitwise
	Bitwise operations for C++11 strong enum class. This casts e into Flag_T and returns value after bitwise operation Use these function as.
	el::base::threading
	el::base::threading::internal
	el::base::debug
	Contains some internal debugging tools like crash handler and stack tracer.

Macros
#define	ELPP_COMPILER_GCC   0
#define	ELPP_COMPILER_MSVC   0
#define	ELPP_CRT_DBG_WARNINGS   ELPP_COMPILER_MSVC
#define	ELPP_COMPILER_CLANG   0
#define	ELPP_MINGW   0
#define	ELPP_CYGWIN   0
#define	ELPP_COMPILER_INTEL   0
#define	ELPP_OS_WINDOWS   0
#define	ELPP_OS_LINUX   0
#define	ELPP_OS_MAC   0
#define	ELPP_OS_FREEBSD   0
#define	ELPP_OS_OPENBSD   0
#define	ELPP_OS_NETBSD   0
#define	ELPP_OS_SOLARIS   0
#define	ELPP_OS_AIX   0
#define	ELPP_OS_NETBSD   0
#define	ELPP_OS_EMSCRIPTEN   0
#define	ELPP_OS_DRAGONFLY   0
#define	ELPP_OS_UNIX   0
#define	ELPP_OS_ANDROID   0
#define	ELPP_INTERNAL_DEBUGGING_OUT_INFO   std::cout
#define	ELPP_INTERNAL_DEBUGGING_OUT_ERROR   std::cerr
#define	ELPP_INTERNAL_DEBUGGING_ENDL   std::endl
#define	ELPP_INTERNAL_DEBUGGING_MSG(msg)   msg
#define	ELPP_ASSERT(expr, msg)
#define	ELPP_INTERNAL_DEBUGGING_WRITE_PERROR   ELPP_INTERNAL_DEBUGGING_OUT_ERROR << ": " << strerror(errno) << " [" << errno << "]"; (void)0
#define	ELPP_INTERNAL_ERROR(msg, pe)
#define	ELPP_INTERNAL_INFO(lvl, msg)
#define	ELPP_STACKTRACE   0
#define	ELPP_UNUSED(x)   (void)x
#define	ELPP_EXPORT
#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)
#define	ELPP_USE_STD_THREADING   0
#define	ELPP_FINAL
#define	ELPP_ASYNC_LOGGING   0
#define	ELPP_THREADING_ENABLED   1
#define	ELPP_FUNC   ""
#define	ELPP_VARIADIC_TEMPLATES_SUPPORTED   (ELPP_COMPILER_GCC || ELPP_COMPILER_CLANG || ELPP_COMPILER_INTEL || (ELPP_COMPILER_MSVC && _MSC_VER >= 1800))
#define	ELPP_LOGGING_ENABLED   1
#define	ELPP_DEBUG_LOG   1
#define	ELPP_INFO_LOG   1
#define	ELPP_WARNING_LOG   1
#define	ELPP_ERROR_LOG   1
#define	ELPP_FATAL_LOG   1
#define	ELPP_TRACE_LOG   1
#define	ELPP_VERBOSE_LOG   1
#define	elpptime_r   gmtime_r
#define	elpptime_s   gmtime_s
#define	elpptime   gmtime
#define	ELPP_LITERAL(txt)   txt
#define	ELPP_STRLEN   strlen
#define	ELPP_COUT   std::cout
#define	ELPP_COUT_LINE(logLine)   logLine << std::flush
#define	ELPP   el::base::Storage::getELPP()
#define	ELPP_SIMPLE_LOG(LOG_TYPE)
#define	ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(temp)
#define	ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(temp)
#define	ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(temp)
#define	ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(temp)
#define	ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG(temp)
#define	MAKE_CONTAINERELPP_FRIENDLY(ContainerType, SizeMethod, ElementInstance)
	Macro used internally that can be used externally to make containers easylogging++ friendly. More...
#define	ELPP_WX_PTR_ENABLED(ContainerType)
#define	ELPP_WX_ENABLED(ContainerType)
#define	ELPP_WX_HASH_MAP_ENABLED(ContainerType)
#define	el_getVALength(...)   el_resolveVALength(0, ## __VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#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, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
#define	ELPP_WRITE_LOG_IF(writer, condition, level, dispatchAction, ...)
#define	ELPP_WRITE_LOG_EVERY_N(writer, occasion, level, dispatchAction, ...)
#define	ELPP_WRITE_LOG_AFTER_N(writer, n, level, dispatchAction, ...)
#define	ELPP_WRITE_LOG_N_TIMES(writer, n, level, dispatchAction, ...)
#define	MAKE_LOGGABLE(ClassType, ClassInstance, OutputStreamInstance)   el::base::type::ostream_t& operator<<(el::base::type::ostream_t& OutputStreamInstance, const ClassType& ClassInstance)
#define	ELPP_INITIALIZE_SYSLOG(id, opt, fac)   el::SysLogInitializer elSyslogInit(id, opt, fac)
#define	VLOG_IS_ON(verboseLevel)   (ELPP->vRegistry()->allowed(verboseLevel, __FILE__))
	Determines whether verbose logging is on for specified level current file. More...
#define	ELPP_MIN_UNIT   el::base::TimestampUnit::Millisecond
#define	TIMED_SCOPE_IF(obj, blockname, condition)
	Performance tracked scope. Performance gets written when goes out of scope using 'performance' logger. More...
#define	TIMED_SCOPE(obj, blockname)   TIMED_SCOPE_IF(obj, blockname, true)
#define	TIMED_BLOCK(obj, blockName)
#define	TIMED_FUNC_IF(obj, condition)   TIMED_SCOPE_IF(obj, ELPP_FUNC, condition)
	Performance tracked function. Performance gets written when goes out of scope using 'performance' logger. More...
#define	TIMED_FUNC(obj)   TIMED_SCOPE(obj, ELPP_FUNC)
#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)
#define	ELPP_COUNTER   (ELPP->hitCounters()->getCounter(__FILE__, __LINE__))
	Gets hit counter for file/line. More...
#define	ELPP_COUNTER_POS   (ELPP_COUNTER == nullptr ? -1 : ELPP_COUNTER->hitCounts())
	Gets hit counter position for file/line, -1 if not registered yet. More...
#define	CINFO(writer, dispatchAction, ...)   ELPP_WRITE_LOG(writer, el::Level::Info, dispatchAction, __VA_ARGS__)
#define	CWARNING(writer, dispatchAction, ...)   ELPP_WRITE_LOG(writer, el::Level::Warning, dispatchAction, __VA_ARGS__)
#define	CDEBUG(writer, dispatchAction, ...)   ELPP_WRITE_LOG(writer, el::Level::Debug, dispatchAction, __VA_ARGS__)
#define	CERROR(writer, dispatchAction, ...)   ELPP_WRITE_LOG(writer, el::Level::Error, dispatchAction, __VA_ARGS__)
#define	CFATAL(writer, dispatchAction, ...)   ELPP_WRITE_LOG(writer, el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define	CTRACE(writer, dispatchAction, ...)   ELPP_WRITE_LOG(writer, el::Level::Trace, dispatchAction, __VA_ARGS__)
#define	CVERBOSE(writer, vlevel, dispatchAction, ...)
#define	CINFO_IF(writer, condition_, dispatchAction, ...)   ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Info, dispatchAction, __VA_ARGS__)
#define	CWARNING_IF(writer, condition_, dispatchAction, ...)   ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Warning, dispatchAction, __VA_ARGS__)
#define	CDEBUG_IF(writer, condition_, dispatchAction, ...)   ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Debug, dispatchAction, __VA_ARGS__)
#define	CERROR_IF(writer, condition_, dispatchAction, ...)   ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Error, dispatchAction, __VA_ARGS__)
#define	CFATAL_IF(writer, condition_, dispatchAction, ...)   ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define	CTRACE_IF(writer, condition_, dispatchAction, ...)   ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Trace, dispatchAction, __VA_ARGS__)
#define	CVERBOSE_IF(writer, condition_, vlevel, dispatchAction, ...)
#define	CINFO_EVERY_N(writer, occasion, dispatchAction, ...)   ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Info, dispatchAction, __VA_ARGS__)
#define	CWARNING_EVERY_N(writer, occasion, dispatchAction, ...)   ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Warning, dispatchAction, __VA_ARGS__)
#define	CDEBUG_EVERY_N(writer, occasion, dispatchAction, ...)   ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Debug, dispatchAction, __VA_ARGS__)
#define	CERROR_EVERY_N(writer, occasion, dispatchAction, ...)   ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Error, dispatchAction, __VA_ARGS__)
#define	CFATAL_EVERY_N(writer, occasion, dispatchAction, ...)   ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define	CTRACE_EVERY_N(writer, occasion, dispatchAction, ...)   ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Trace, dispatchAction, __VA_ARGS__)
#define	CVERBOSE_EVERY_N(writer, occasion, vlevel, dispatchAction, ...)   CVERBOSE_IF(writer, ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion), vlevel, dispatchAction, __VA_ARGS__)
#define	CINFO_AFTER_N(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__)
#define	CWARNING_AFTER_N(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__)
#define	CDEBUG_AFTER_N(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__)
#define	CERROR_AFTER_N(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__)
#define	CFATAL_AFTER_N(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define	CTRACE_AFTER_N(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__)
#define	CVERBOSE_AFTER_N(writer, n, vlevel, dispatchAction, ...)   CVERBOSE_IF(writer, ELPP->validateAfterNCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__)
#define	CINFO_N_TIMES(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__)
#define	CWARNING_N_TIMES(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__)
#define	CDEBUG_N_TIMES(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__)
#define	CERROR_N_TIMES(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__)
#define	CFATAL_N_TIMES(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define	CTRACE_N_TIMES(writer, n, dispatchAction, ...)   ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__)
#define	CVERBOSE_N_TIMES(writer, n, vlevel, dispatchAction, ...)   CVERBOSE_IF(writer, ELPP->validateNTimesCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__)
#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__)
#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__)
#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__)
#define	ELPP_CURR_FILE_LOGGER_ID   el::base::consts::kDefaultLoggerId
#define	ELPP_TRACE   CLOG(TRACE, ELPP_CURR_FILE_LOGGER_ID)
#define	LOG(LEVEL)   CLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define	VLOG(vlevel)   CVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID)
#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)
#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)
#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)
#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()
#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__)
#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__)
#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__)
#define	ELPP_USE_DEF_CRASH_HANDLER   false
#define	ELPP_CRASH_HANDLER_INIT
#define	ELPP_INIT_EASYLOGGINGPP(val)
#define	INITIALIZE_EASYLOGGINGPP   ELPP_INIT_EASYLOGGINGPP(new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder())))
#define	INITIALIZE_NULL_EASYLOGGINGPP
#define	SHARE_EASYLOGGINGPP(initializedStorage)
#define	START_EASYLOGGINGPP(argc, argv)   el::Helpers::setArgs(argc, argv)

Typedefs
typedef char	el::base::type::char_t
typedef std::string	el::base::type::string_t
typedef std::stringstream	el::base::type::stringstream_t
typedef std::fstream	el::base::type::fstream_t
typedef std::ostream	el::base::type::ostream_t
typedef unsigned int	el::base::type::EnumType
typedef unsigned short	el::base::type::VerboseLevel
typedef unsigned long int	el::base::type::LineNumber
typedef base::Storage *	el::base::type::StoragePointer
typedef std::shared_ptr< LogDispatchCallback >	el::base::type::LogDispatchCallbackPtr
typedef std::shared_ptr< PerformanceTrackingCallback >	el::base::type::PerformanceTrackingCallbackPtr
typedef std::shared_ptr< LoggerRegistrationCallback >	el::base::type::LoggerRegistrationCallbackPtr
typedef std::unique_ptr< el::base::PerformanceTracker >	el::base::type::PerformanceTrackerPtr
typedef std::function< void(const char *, std::size_t)>	el::PreRollOutCallback
typedef SubsecondPrecision	el::base::MillisecondsWidth
	Type alias of SubsecondPrecision. More...
typedef base::threading::internal::Mutex	el::base::threading::Mutex
typedef base::threading::internal::ScopedLock< base::threading::Mutex >	el::base::threading::ScopedLock
typedef std::function< std::string(const LogMessage *)>	el::FormatSpecifierValueResolver
	Resolving function for format specifier. More...
typedef std::shared_ptr< base::type::fstream_t >	el::base::FileStreamPtr
typedef std::unordered_map< std::string, FileStreamPtr >	el::base::LogStreamsReferenceMap
typedef std::shared_ptr< LogBuilder >	el::LogBuilderPtr

Enumerations
enum	el::Level : base::type::EnumType {   el::Level::Global = 1, el::Level::Trace = 2, el::Level::Debug = 4, el::Level::Fatal = 8,   el::Level::Error = 16, el::Level::Warning = 32, el::Level::Verbose = 64, el::Level::Info = 128,   el::Level::Unknown = 1010 }
	Represents enumeration for severity level used to determine level of logging. More...
enum	el::Color : base::type::EnumType {   el::Color::Default, el::Color::Red, el::Color::Green, el::Color::Yellow,   el::Color::Blue, el::Color::Magenta, el::Color::Cyan }
enum	el::ConfigurationType : base::type::EnumType {   el::ConfigurationType::Enabled = 1, el::ConfigurationType::ToFile = 2, el::ConfigurationType::ToStandardOutput = 4, el::ConfigurationType::Format = 8,   el::ConfigurationType::Filename = 16, el::ConfigurationType::SubsecondPrecision = 32, el::ConfigurationType::MillisecondsWidth = SubsecondPrecision, el::ConfigurationType::PerformanceTracking = 64,   el::ConfigurationType::MaxLogFileSize = 128, el::ConfigurationType::LogFlushThreshold = 256, el::ConfigurationType::Unknown = 1010 }
	Represents enumeration of ConfigurationType used to configure or access certain aspect of logging. More...
enum	el::LoggingFlag : base::type::EnumType {   el::LoggingFlag::NewLineForContainer = 1, el::LoggingFlag::AllowVerboseIfModuleNotSpecified = 2, el::LoggingFlag::LogDetailedCrashReason = 4, el::LoggingFlag::DisableApplicationAbortOnFatalLog = 8,   el::LoggingFlag::ImmediateFlush = 16, el::LoggingFlag::StrictLogFileSizeCheck = 32, el::LoggingFlag::ColoredTerminalOutput = 64, el::LoggingFlag::MultiLoggerSupport = 128,   el::LoggingFlag::DisablePerformanceTrackingCheckpointComparison = 256, el::LoggingFlag::DisableVModules = 512, el::LoggingFlag::DisableVModulesExtensions = 1024, el::LoggingFlag::HierarchicalLogging = 2048,   el::LoggingFlag::CreateLoggerAutomatically = 4096, el::LoggingFlag::AutoSpacing = 8192, el::LoggingFlag::FixedTimeFormat = 16384, el::LoggingFlag::IgnoreSigInt = 32768 }
	Flags used while writing logs. This flags are set by user. More...
enum	el::base::TimestampUnit : base::type::EnumType {   el::base::TimestampUnit::Microsecond = 0, el::base::TimestampUnit::Millisecond = 1, el::base::TimestampUnit::Second = 2, el::base::TimestampUnit::Minute = 3,   el::base::TimestampUnit::Hour = 4, el::base::TimestampUnit::Day = 5 }
	Enum to represent timestamp unit. More...
enum	el::base::FormatFlags : base::type::EnumType {   el::base::FormatFlags::DateTime = 1 << 1, el::base::FormatFlags::LoggerId = 1 << 2, el::base::FormatFlags::File = 1 << 3, el::base::FormatFlags::Line = 1 << 4,   el::base::FormatFlags::Location = 1 << 5, el::base::FormatFlags::Function = 1 << 6, el::base::FormatFlags::User = 1 << 7, el::base::FormatFlags::Host = 1 << 8,   el::base::FormatFlags::LogMessage = 1 << 9, el::base::FormatFlags::VerboseLevel = 1 << 10, el::base::FormatFlags::AppName = 1 << 11, el::base::FormatFlags::ThreadId = 1 << 12,   el::base::FormatFlags::Level = 1 << 13, el::base::FormatFlags::FileBase = 1 << 14, el::base::FormatFlags::LevelShort = 1 << 15 }
	Format flags used to determine specifiers that are active for performance improvements. More...
enum	el::base::DispatchAction : base::type::EnumType { el::base::DispatchAction::None = 1, el::base::DispatchAction::NormalLog = 2, el::base::DispatchAction::SysLog = 4, el::base::DispatchAction::FileOnlyLog = 8 }
	Action to be taken for dispatching. More...

Functions
static void	el::base::defaultPreRollOutCallback (const char *, std::size_t)
template<typename T >
static std::enable_if< std::is_pointer< T * >::value, void >::type	el::base::utils::safeDelete (T *&pointer)
	Deletes memory safely and points to null. More...
template<typename Enum >
static base::type::EnumType	el::base::utils::bitwise::And (Enum e, base::type::EnumType flag)
template<typename Enum >
static base::type::EnumType	el::base::utils::bitwise::Not (Enum e, base::type::EnumType flag)
template<typename Enum >
static base::type::EnumType	el::base::utils::bitwise::Or (Enum e, base::type::EnumType flag)
template<typename Enum >
static void	el::base::utils::addFlag (Enum e, base::type::EnumType *flag)
template<typename Enum >
static void	el::base::utils::removeFlag (Enum e, base::type::EnumType *flag)
template<typename Enum >
static bool	el::base::utils::hasFlag (Enum e, base::type::EnumType flag)
static std::string	el::base::threading::getCurrentThreadId (void)
	Gets ID of currently running threading in windows systems. On unix, nothing is returned. More...

Variables
static const char	el::base::consts::kFormatSpecifierCharValue = 'v'
static const char	el::base::consts::kFormatSpecifierChar = '%'
static const unsigned int	el::base::consts::kMaxLogPerCounter = 100000
static const unsigned int	el::base::consts::kMaxLogPerContainer = 100
static const unsigned int	el::base::consts::kDefaultSubsecondPrecision = 3
static const char *	el::base::consts::kDefaultLoggerId = "default"
static const char *	el::base::consts::kFilePathSeperator = "/"
static const std::size_t	el::base::consts::kSourceFilenameMaxLength = 100
static const std::size_t	el::base::consts::kSourceLineMaxLength = 10
static const Level	el::base::consts::kPerformanceTrackerDefaultLevel = Level::Info
struct {
double   el::base::consts::value
const base::type::char_t *   el::base::consts::unit
}	el::base::consts::kTimeFormats []
static const int	el::base::consts::kTimeFormatsCount = sizeof(kTimeFormats) / sizeof(kTimeFormats[0])
struct {
int   el::base::consts::numb
const char *   el::base::consts::name
const char *   el::base::consts::brief
const char *   el::base::consts::detail
}	el::base::consts::kCrashSignals []
static const int	el::base::consts::kCrashSignalsCount = sizeof(kCrashSignals) / sizeof(kCrashSignals[0])
ELPP_EXPORT base::type::StoragePointer	el::base::elStorage
base::debug::CrashHandler	el::elCrashHandler

Macro Definition Documentation

CDEBUG

#define CDEBUG	(		writer,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG(writer, el::Level::Debug, dispatchAction, __VA_ARGS__)

CDEBUG_AFTER_N

#define CDEBUG_AFTER_N	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__)

CDEBUG_EVERY_N

#define CDEBUG_EVERY_N	(		writer,
			occasion,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Debug, dispatchAction, __VA_ARGS__)

CDEBUG_IF

#define CDEBUG_IF	(		writer,
			condition_,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Debug, dispatchAction, __VA_ARGS__)

CDEBUG_N_TIMES

#define CDEBUG_N_TIMES	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__)

CERROR

#define CERROR	(		writer,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG(writer, el::Level::Error, dispatchAction, __VA_ARGS__)

CERROR_AFTER_N

#define CERROR_AFTER_N	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__)

CERROR_EVERY_N

#define CERROR_EVERY_N	(		writer,
			occasion,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Error, dispatchAction, __VA_ARGS__)

CERROR_IF

#define CERROR_IF	(		writer,
			condition_,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Error, dispatchAction, __VA_ARGS__)

CERROR_N_TIMES

#define CERROR_N_TIMES	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__)

CFATAL

#define CFATAL	(		writer,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG(writer, el::Level::Fatal, dispatchAction, __VA_ARGS__)

CFATAL_AFTER_N

#define CFATAL_AFTER_N	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__)

CFATAL_EVERY_N

#define CFATAL_EVERY_N	(		writer,
			occasion,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Fatal, dispatchAction, __VA_ARGS__)

CFATAL_IF

#define CFATAL_IF	(		writer,
			condition_,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Fatal, dispatchAction, __VA_ARGS__)

CFATAL_N_TIMES

#define CFATAL_N_TIMES	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__)

CINFO

#define CINFO	(		writer,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG(writer, el::Level::Info, dispatchAction, __VA_ARGS__)

CINFO_AFTER_N

#define CINFO_AFTER_N	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__)

CINFO_EVERY_N

#define CINFO_EVERY_N	(		writer,
			occasion,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Info, dispatchAction, __VA_ARGS__)

CINFO_IF

#define CINFO_IF	(		writer,
			condition_,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Info, dispatchAction, __VA_ARGS__)

CINFO_N_TIMES

#define CINFO_N_TIMES	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__)

CLOG

#define CLOG	(		LEVEL,
			...
	)		C##LEVEL(el::base::Writer, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CLOG_AFTER_N

#define CLOG_AFTER_N	(		n,
			LEVEL,
			...
	)		C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CLOG_EVERY_N

#define CLOG_EVERY_N	(		n,
			LEVEL,
			...
	)		C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CLOG_IF

#define CLOG_IF	(		condition,
			LEVEL,
			...
	)		C##LEVEL##_IF(el::base::Writer, condition, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CLOG_N_TIMES

#define CLOG_N_TIMES	(		n,
			LEVEL,
			...
	)		C##LEVEL##_N_TIMES(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CPLOG

#define CPLOG	(		LEVEL,
			...
	)		C##LEVEL(el::base::PErrorWriter, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CPLOG_IF

#define CPLOG_IF	(		condition,
			LEVEL,
			...
	)		C##LEVEL##_IF(el::base::PErrorWriter, condition, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CSYSLOG

#define CSYSLOG	(		LEVEL,
			...
	)		el::base::NullWriter()

CSYSLOG_AFTER_N

#define CSYSLOG_AFTER_N	(		n,
			LEVEL,
			...
	)		el::base::NullWriter()

CSYSLOG_EVERY_N

#define CSYSLOG_EVERY_N	(		n,
			LEVEL,
			...
	)		el::base::NullWriter()

CSYSLOG_IF

#define CSYSLOG_IF	(		condition,
			LEVEL,
			...
	)		el::base::NullWriter()

CSYSLOG_N_TIMES

#define CSYSLOG_N_TIMES	(		n,
			LEVEL,
			...
	)		el::base::NullWriter()

CTRACE

#define CTRACE	(		writer,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG(writer, el::Level::Trace, dispatchAction, __VA_ARGS__)

CTRACE_AFTER_N

#define CTRACE_AFTER_N	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__)

CTRACE_EVERY_N

#define CTRACE_EVERY_N	(		writer,
			occasion,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Trace, dispatchAction, __VA_ARGS__)

CTRACE_IF

#define CTRACE_IF	(		writer,
			condition_,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Trace, dispatchAction, __VA_ARGS__)

CTRACE_N_TIMES

#define CTRACE_N_TIMES	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__)

CVERBOSE

#define CVERBOSE	(		writer,
			vlevel,
			dispatchAction,
			...
	)

Value:

if (VLOG_IS_ON(vlevel)) writer(\
el::Level::Verbose, __FILE__, __LINE__, ELPP_FUNC, dispatchAction, vlevel).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)

CVERBOSE_AFTER_N

#define CVERBOSE_AFTER_N	(		writer,
			n,
			vlevel,
			dispatchAction,
			...
	)		CVERBOSE_IF(writer, ELPP->validateAfterNCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__)

CVERBOSE_EVERY_N

#define CVERBOSE_EVERY_N	(		writer,
			occasion,
			vlevel,
			dispatchAction,
			...
	)		CVERBOSE_IF(writer, ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion), vlevel, dispatchAction, __VA_ARGS__)

CVERBOSE_IF

#define CVERBOSE_IF	(		writer,
			condition_,
			vlevel,
			dispatchAction,
			...
	)

Value:

if (VLOG_IS_ON(vlevel) && (condition_)) writer( \
el::Level::Verbose, __FILE__, __LINE__, ELPP_FUNC, dispatchAction, vlevel).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)

CVERBOSE_N_TIMES

#define CVERBOSE_N_TIMES	(		writer,
			n,
			vlevel,
			dispatchAction,
			...
	)		CVERBOSE_IF(writer, ELPP->validateNTimesCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__)

CVLOG

#define CVLOG	(		vlevel,
			...
	)		CVERBOSE(el::base::Writer, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CVLOG_AFTER_N

#define CVLOG_AFTER_N	(		n,
			vlevel,
			...
	)		CVERBOSE_AFTER_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CVLOG_EVERY_N

#define CVLOG_EVERY_N	(		n,
			vlevel,
			...
	)		CVERBOSE_EVERY_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CVLOG_IF

#define CVLOG_IF	(		condition,
			vlevel,
			...
	)		CVERBOSE_IF(el::base::Writer, condition, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CVLOG_N_TIMES

#define CVLOG_N_TIMES	(		n,
			vlevel,
			...
	)		CVERBOSE_N_TIMES(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)

CWARNING

#define CWARNING	(		writer,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG(writer, el::Level::Warning, dispatchAction, __VA_ARGS__)

CWARNING_AFTER_N

#define CWARNING_AFTER_N	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__)

CWARNING_EVERY_N

#define CWARNING_EVERY_N	(		writer,
			occasion,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Warning, dispatchAction, __VA_ARGS__)

CWARNING_IF

#define CWARNING_IF	(		writer,
			condition_,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Warning, dispatchAction, __VA_ARGS__)

CWARNING_N_TIMES

#define CWARNING_N_TIMES	(		writer,
			n,
			dispatchAction,
			...
	)		ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__)

DCLOG

#define DCLOG	(		LEVEL,
			...
	)		if (ELPP_DEBUG_LOG) CLOG(LEVEL, __VA_ARGS__)

DCLOG_AFTER_N

#define DCLOG_AFTER_N	(		n,
			LEVEL,
			...
	)		if (ELPP_DEBUG_LOG) CLOG_AFTER_N(n, LEVEL, __VA_ARGS__)

DCLOG_EVERY_N

#define DCLOG_EVERY_N	(		n,
			LEVEL,
			...
	)		if (ELPP_DEBUG_LOG) CLOG_EVERY_N(n, LEVEL, __VA_ARGS__)

DCLOG_IF

#define DCLOG_IF	(		condition,
			LEVEL,
			...
	)		if (ELPP_DEBUG_LOG) CLOG_IF(condition, LEVEL, __VA_ARGS__)

DCLOG_N_TIMES

#define DCLOG_N_TIMES	(		n,
			LEVEL,
			...
	)		if (ELPP_DEBUG_LOG) CLOG_N_TIMES(n, LEVEL, __VA_ARGS__)

DCLOG_VERBOSE

#define DCLOG_VERBOSE	(		vlevel,
			...
	)		if (ELPP_DEBUG_LOG) CLOG_VERBOSE(vlevel, __VA_ARGS__)

DCPLOG

#define DCPLOG	(		LEVEL,
			...
	)		if (ELPP_DEBUG_LOG) C##LEVEL(el::base::PErrorWriter, el::base::DispatchAction::NormalLog, __VA_ARGS__)

DCPLOG_IF

#define DCPLOG_IF	(		condition,
			LEVEL,
			...
	)		C##LEVEL##_IF(el::base::PErrorWriter, (ELPP_DEBUG_LOG) && (condition), el::base::DispatchAction::NormalLog, __VA_ARGS__)

DCSYSLOG

#define DCSYSLOG	(		LEVEL,
			...
	)		el::base::NullWriter()

DCSYSLOG_AFTER_N

#define DCSYSLOG_AFTER_N	(		n,
			LEVEL,
			...
	)		el::base::NullWriter()

DCSYSLOG_EVERY_N

#define DCSYSLOG_EVERY_N	(		n,
			LEVEL,
			...
	)		el::base::NullWriter()

DCSYSLOG_IF

#define DCSYSLOG_IF	(		condition,
			LEVEL,
			...
	)		el::base::NullWriter()

DCSYSLOG_N_TIMES

#define DCSYSLOG_N_TIMES	(		n,
			LEVEL,
			...
	)		el::base::NullWriter()

DCVLOG

#define DCVLOG	(		vlevel,
			...
	)		if (ELPP_DEBUG_LOG) CVLOG(vlevel, __VA_ARGS__)

DCVLOG_AFTER_N

#define DCVLOG_AFTER_N	(		n,
			vlevel,
			...
	)		if (ELPP_DEBUG_LOG) CVLOG_AFTER_N(n, vlevel, __VA_ARGS__)

DCVLOG_EVERY_N

#define DCVLOG_EVERY_N	(		n,
			vlevel,
			...
	)		if (ELPP_DEBUG_LOG) CVLOG_EVERY_N(n, vlevel, __VA_ARGS__)

DCVLOG_IF

#define DCVLOG_IF	(		condition,
			vlevel,
			...
	)		if (ELPP_DEBUG_LOG) CVLOG_IF(condition, vlevel, __VA_ARGS__)

DCVLOG_N_TIMES

#define DCVLOG_N_TIMES	(		n,
			vlevel,
			...
	)		if (ELPP_DEBUG_LOG) CVLOG_N_TIMES(n, vlevel, __VA_ARGS__)

DPLOG

#define DPLOG

(

LEVEL

)

DCPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)

DPLOG_IF

#define DPLOG_IF	(		condition,
			LEVEL
	)		DCPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)

DSYSLOG

#define DSYSLOG

(

LEVEL

)

el::base::NullWriter()

DSYSLOG_AFTER_N

#define DSYSLOG_AFTER_N	(		n,
			LEVEL
	)		el::base::NullWriter()

DSYSLOG_EVERY_N

#define DSYSLOG_EVERY_N	(		n,
			LEVEL
	)		el::base::NullWriter()

DSYSLOG_IF

#define DSYSLOG_IF	(		condition,
			LEVEL
	)		el::base::NullWriter()

DSYSLOG_N_TIMES

#define DSYSLOG_N_TIMES	(		n,
			LEVEL
	)		el::base::NullWriter()

el_getVALength

#define el_getVALength

(

...

)

el_resolveVALength(0, ## __VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

el_resolveVALength

#define el_resolveVALength	(		_0,
			_1,
			_2,
			_3,
			_4,
			_5,
			_6,
			_7,
			_8,
			_9,
			_10,
			N,
			...
	)		N

ELPP

#define ELPP   el::base::Storage::getELPP()

ELPP_ASSERT

#define ELPP_ASSERT	(		expr,
			msg
	)

Value:

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; }

ELPP_ASYNC_LOGGING

#define ELPP_ASYNC_LOGGING   0

ELPP_COMPILER_CLANG

#define ELPP_COMPILER_CLANG   0

ELPP_COMPILER_GCC

#define ELPP_COMPILER_GCC   0

ELPP_COMPILER_INTEL

#define ELPP_COMPILER_INTEL   0

ELPP_COMPILER_MSVC

#define ELPP_COMPILER_MSVC   0

ELPP_COUNTER

#define ELPP_COUNTER   (ELPP->hitCounters()->getCounter(__FILE__, __LINE__))

Gets hit counter for file/line.

ELPP_COUNTER_POS

#define ELPP_COUNTER_POS   (ELPP_COUNTER == nullptr ? -1 : ELPP_COUNTER->hitCounts())

Gets hit counter position for file/line, -1 if not registered yet.

ELPP_COUT

#define ELPP_COUT   std::cout

ELPP_COUT_LINE

#define ELPP_COUT_LINE

(

logLine

)

logLine << std::flush

ELPP_CRASH_HANDLER_INIT

#define ELPP_CRASH_HANDLER_INIT

ELPP_CRT_DBG_WARNINGS

#define ELPP_CRT_DBG_WARNINGS   ELPP_COMPILER_MSVC

ELPP_CURR_FILE_LOGGER_ID

#define ELPP_CURR_FILE_LOGGER_ID   el::base::consts::kDefaultLoggerId

ELPP_CYGWIN

#define ELPP_CYGWIN   0

ELPP_DEBUG_LOG

#define ELPP_DEBUG_LOG   1

ELPP_ERROR_LOG

#define ELPP_ERROR_LOG   1

ELPP_EXPORT

#define ELPP_EXPORT

ELPP_FATAL_LOG

#define ELPP_FATAL_LOG   1

ELPP_FINAL

#define ELPP_FINAL

ELPP_FUNC

#define ELPP_FUNC   ""

ELPP_INFO_LOG

#define ELPP_INFO_LOG   1

ELPP_INIT_EASYLOGGINGPP

#define ELPP_INIT_EASYLOGGINGPP

(

val

)

Value:

namespace el { \
namespace base { \
el::base::type::StoragePointer elStorage(val); \
} \
el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER); \
}

ELPP_INITIALIZE_SYSLOG

#define ELPP_INITIALIZE_SYSLOG	(		id,
			opt,
			fac
	)		el::SysLogInitializer elSyslogInit(id, opt, fac)

ELPP_INTERNAL_DEBUGGING_ENDL

#define ELPP_INTERNAL_DEBUGGING_ENDL   std::endl

ELPP_INTERNAL_DEBUGGING_MSG

#define ELPP_INTERNAL_DEBUGGING_MSG

(

msg

)

msg

ELPP_INTERNAL_DEBUGGING_OUT_ERROR

#define ELPP_INTERNAL_DEBUGGING_OUT_ERROR   std::cerr

ELPP_INTERNAL_DEBUGGING_OUT_INFO

#define ELPP_INTERNAL_DEBUGGING_OUT_INFO   std::cout

ELPP_INTERNAL_DEBUGGING_WRITE_PERROR

#define ELPP_INTERNAL_DEBUGGING_WRITE_PERROR   ELPP_INTERNAL_DEBUGGING_OUT_ERROR << ": " << strerror(errno) << " [" << errno << "]"; (void)0

ELPP_INTERNAL_ERROR

#define ELPP_INTERNAL_ERROR	(		msg,
			pe
	)

ELPP_INTERNAL_INFO

#define ELPP_INTERNAL_INFO	(		lvl,
			msg
	)

ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG

#define ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG

(

temp

)

Value:

template <typename T1, typename T2, typename T3, typename T4, typename T5>                       \
inline MessageBuilder& operator<<(const temp<T1, T2, T3, T4, T5>& template_inst) {               \
return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
}

ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG

#define ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG

(

temp

)

Value:

template <typename T1, typename T2, typename T3, typename T4>                                    \
inline MessageBuilder& operator<<(const temp<T1, T2, T3, T4>& template_inst) {                   \
return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
}

ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG

#define ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG

(

temp

)

Value:

template <typename T>                                                                            \
inline MessageBuilder& operator<<(const temp<T>& template_inst) {                                \
return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
}

ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG

#define ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG

(

temp

)

Value:

template <typename T1, typename T2, typename T3>                                                 \
inline MessageBuilder& operator<<(const temp<T1, T2, T3>& template_inst) {                       \
return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
}

ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG

#define ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG

(

temp

)

Value:

template <typename T1, typename T2>                                                              \
inline MessageBuilder& operator<<(const temp<T1, T2>& template_inst) {                           \
return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
}

ELPP_LITERAL

#define ELPP_LITERAL

(

txt

)

txt

ELPP_LOGGING_ENABLED

#define ELPP_LOGGING_ENABLED   1

ELPP_MIN_UNIT

#define ELPP_MIN_UNIT   el::base::TimestampUnit::Millisecond

ELPP_MINGW

#define ELPP_MINGW   0

ELPP_OS_AIX

#define ELPP_OS_AIX   0

ELPP_OS_ANDROID

#define ELPP_OS_ANDROID   0

ELPP_OS_DRAGONFLY

#define ELPP_OS_DRAGONFLY   0

ELPP_OS_EMSCRIPTEN

#define ELPP_OS_EMSCRIPTEN   0

ELPP_OS_FREEBSD

#define ELPP_OS_FREEBSD   0

ELPP_OS_LINUX

#define ELPP_OS_LINUX   0

ELPP_OS_MAC

#define ELPP_OS_MAC   0

ELPP_OS_NETBSD [1/2]

#define ELPP_OS_NETBSD   0

ELPP_OS_NETBSD [2/2]

#define ELPP_OS_NETBSD   0

ELPP_OS_OPENBSD

#define ELPP_OS_OPENBSD   0

ELPP_OS_SOLARIS

#define ELPP_OS_SOLARIS   0

ELPP_OS_UNIX

#define ELPP_OS_UNIX   0

ELPP_OS_WINDOWS

#define ELPP_OS_WINDOWS   0

ELPP_SIMPLE_LOG

#define ELPP_SIMPLE_LOG

(

LOG_TYPE

)

Value:

MessageBuilder& operator<<(LOG_TYPE msg) {\
m_logger->stream() << msg;\
if (ELPP->hasFlag(LoggingFlag::AutoSpacing)) {\
m_logger->stream() << " ";\
}\
return *this;\
}

ELPP_STACKTRACE

#define ELPP_STACKTRACE   0

ELPP_STRLEN

#define ELPP_STRLEN   strlen

ELPP_THREADING_ENABLED

#define ELPP_THREADING_ENABLED   1

ELPP_TRACE

#define ELPP_TRACE   CLOG(TRACE, ELPP_CURR_FILE_LOGGER_ID)

ELPP_TRACE_LOG

#define ELPP_TRACE_LOG   1

ELPP_UNUSED

#define ELPP_UNUSED

(

x

)

(void)x

ELPP_USE_DEF_CRASH_HANDLER

#define ELPP_USE_DEF_CRASH_HANDLER   false

ELPP_USE_STD_THREADING

#define ELPP_USE_STD_THREADING   0

ELPP_VARIADIC_TEMPLATES_SUPPORTED

#define ELPP_VARIADIC_TEMPLATES_SUPPORTED   (ELPP_COMPILER_GCC || ELPP_COMPILER_CLANG || ELPP_COMPILER_INTEL || (ELPP_COMPILER_MSVC && _MSC_VER >= 1800))

ELPP_VERBOSE_LOG

#define ELPP_VERBOSE_LOG   1

ELPP_WARNING_LOG

#define ELPP_WARNING_LOG   1

ELPP_WRITE_LOG

#define ELPP_WRITE_LOG	(		writer,
			level,
			dispatchAction,
			...
	)		writer(level, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)

ELPP_WRITE_LOG_AFTER_N

#define ELPP_WRITE_LOG_AFTER_N	(		writer,
			n,
			level,
			dispatchAction,
			...
	)

Value:

ELPP->validateAfterNCounter(__FILE__, __LINE__, n) && \
writer(level, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)

ELPP_WRITE_LOG_EVERY_N

#define ELPP_WRITE_LOG_EVERY_N	(		writer,
			occasion,
			level,
			dispatchAction,
			...
	)

Value:

ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion) && \
writer(level, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)

ELPP_WRITE_LOG_IF

#define ELPP_WRITE_LOG_IF	(		writer,
			condition,
			level,
			dispatchAction,
			...
	)

Value:

if (condition) \
writer(level, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)

ELPP_WRITE_LOG_N_TIMES

#define ELPP_WRITE_LOG_N_TIMES	(		writer,
			n,
			level,
			dispatchAction,
			...
	)

Value:

ELPP->validateNTimesCounter(__FILE__, __LINE__, n) && \
writer(level, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)

ELPP_WX_ENABLED

#define ELPP_WX_ENABLED

(

ContainerType

)

ELPP_WX_HASH_MAP_ENABLED

#define ELPP_WX_HASH_MAP_ENABLED

(

ContainerType

)

ELPP_WX_PTR_ENABLED

#define ELPP_WX_PTR_ENABLED

(

ContainerType

)

elpptime

#define elpptime   gmtime

elpptime_r

#define elpptime_r   gmtime_r

elpptime_s

#define elpptime_s   gmtime_s

INITIALIZE_EASYLOGGINGPP

#define INITIALIZE_EASYLOGGINGPP   ELPP_INIT_EASYLOGGINGPP(new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder())))

INITIALIZE_NULL_EASYLOGGINGPP

#define INITIALIZE_NULL_EASYLOGGINGPP

Value:

namespace el {\
namespace base {\
el::base::type::StoragePointer elStorage;\
}\
el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\
}

LOG

#define LOG

(

LEVEL

)

CLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)

LOG_AFTER_N

#define LOG_AFTER_N	(		n,
			LEVEL
	)		CLOG_AFTER_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)

LOG_EVERY_N

#define LOG_EVERY_N	(		n,
			LEVEL
	)		CLOG_EVERY_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)

LOG_IF

#define LOG_IF	(		condition,
			LEVEL
	)		CLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)

LOG_N_TIMES

#define LOG_N_TIMES	(		n,
			LEVEL
	)		CLOG_N_TIMES(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)

MAKE_CONTAINERELPP_FRIENDLY

#define MAKE_CONTAINERELPP_FRIENDLY	(		ContainerType,
			SizeMethod,
			ElementInstance
	)

Value:

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;\
}

Macro used internally that can be used externally to make containers easylogging++ friendly.

This macro expands to write an ostream& operator<< for container. This container is expected to have begin() and end() methods that return respective iterators

Parameters

ContainerType	Type of container e.g, MyList from WX_DECLARE_LIST(int, MyList); in wxwidgets
SizeMethod	Method used to get size of container.
ElementInstance	Instance of element to be fed out. Insance name is "elem". See WXELPP_ENABLED macro for an example usage

MAKE_LOGGABLE

#define MAKE_LOGGABLE	(		ClassType,
			ClassInstance,
			OutputStreamInstance
	)		el::base::type::ostream_t& operator<<(el::base::type::ostream_t& OutputStreamInstance, const ClassType& ClassInstance)

PERFORMANCE_CHECKPOINT

#define PERFORMANCE_CHECKPOINT

(

obj

)

obj->checkpoint(std::string(), __FILE__, __LINE__, ELPP_FUNC)

PERFORMANCE_CHECKPOINT_WITH_ID

#define PERFORMANCE_CHECKPOINT_WITH_ID	(		obj,
			id
	)		obj->checkpoint(id, __FILE__, __LINE__, ELPP_FUNC)

PLOG

#define PLOG

(

LEVEL

)

CPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)

PLOG_IF

#define PLOG_IF	(		condition,
			LEVEL
	)		CPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)

SHARE_EASYLOGGINGPP

#define SHARE_EASYLOGGINGPP

(

initializedStorage

)

Value:

namespace el {\
namespace base {\
el::base::type::StoragePointer elStorage(initializedStorage);\
}\
el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\
}

START_EASYLOGGINGPP

#define START_EASYLOGGINGPP	(		argc,
			argv
	)		el::Helpers::setArgs(argc, argv)

STRCAT

#define STRCAT	(		a,
			b,
			len
	)		strcat(a, b)

STRCPY

#define STRCPY	(		a,
			b,
			len
	)		strcpy(a, b)

STRERROR

#define STRERROR	(		a,
			b,
			c
	)		strerror(c)

STRTOK

#define STRTOK	(		a,
			b,
			c
	)		strtok(a, b)

SYSLOG

#define SYSLOG

(

LEVEL

)

el::base::NullWriter()

SYSLOG_AFTER_N

#define SYSLOG_AFTER_N	(		n,
			LEVEL
	)		el::base::NullWriter()

SYSLOG_EVERY_N

#define SYSLOG_EVERY_N	(		n,
			LEVEL
	)		el::base::NullWriter()

SYSLOG_IF

#define SYSLOG_IF	(		condition,
			LEVEL
	)		el::base::NullWriter()

SYSLOG_N_TIMES

#define SYSLOG_N_TIMES	(		n,
			LEVEL
	)		el::base::NullWriter()

TIMED_BLOCK

#define TIMED_BLOCK	(		obj,
			blockName
	)

Value:

for (struct { int i; el::base::type::PerformanceTrackerPtr timer; } obj = { 0, \
  el::base::type::PerformanceTrackerPtr(new el::base::PerformanceTracker(blockName, ELPP_MIN_UNIT)) }; obj.i < 1; ++obj.i)

TIMED_FUNC

#define TIMED_FUNC

(

obj

)

TIMED_SCOPE(obj, ELPP_FUNC)

TIMED_FUNC_IF

#define TIMED_FUNC_IF	(		obj,
			condition
	)		TIMED_SCOPE_IF(obj, ELPP_FUNC, condition)

Performance tracked function. Performance gets written when goes out of scope using 'performance' logger.

Please note in order to check the performance at a certain time you can use obj->checkpoint();

See also

el::base::PerformanceTracker

el::base::PerformanceTracker::checkpoint

TIMED_SCOPE

#define TIMED_SCOPE	(		obj,
			blockname
	)		TIMED_SCOPE_IF(obj, blockname, true)

TIMED_SCOPE_IF

#define TIMED_SCOPE_IF	(		obj,
			blockname,
			condition
	)

Value:

el::base::type::PerformanceTrackerPtr obj( condition ? \
  new el::base::PerformanceTracker(blockname, ELPP_MIN_UNIT) : nullptr )

Performance tracked scope. Performance gets written when goes out of scope using 'performance' logger.

Please note in order to check the performance at a certain time you can use obj->checkpoint();

See also

el::base::PerformanceTracker

el::base::PerformanceTracker::checkpoint

VLOG

#define VLOG

(

vlevel

)

CVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID)

VLOG_AFTER_N

#define VLOG_AFTER_N	(		n,
			vlevel
	)		CVLOG_AFTER_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)

VLOG_EVERY_N

#define VLOG_EVERY_N	(		n,
			vlevel
	)		CVLOG_EVERY_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)

VLOG_IF

#define VLOG_IF	(		condition,
			vlevel
	)		CVLOG_IF(condition, vlevel, ELPP_CURR_FILE_LOGGER_ID)

VLOG_IS_ON

#define VLOG_IS_ON

(

verboseLevel

)

(ELPP->vRegistry()->allowed(verboseLevel, __FILE__))

Determines whether verbose logging is on for specified level current file.

VLOG_N_TIMES

#define VLOG_N_TIMES	(		n,
			vlevel
	)		CVLOG_N_TIMES(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)