ifw  0.0.1-dev
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Namespaces | Macros | Enumerations
easylogging++.h File Reference
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include <cwchar>
#include <csignal>
#include <cerrno>
#include <cstdarg>
#include <string>
#include <vector>
#include <map>
#include <utility>
#include <functional>
#include <algorithm>
#include <fstream>
#include <iostream>
#include <sstream>
#include <memory>
#include <type_traits>

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...
 
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::MillisecondsWidth
 A milliseconds width class containing actual width and offset for date/time. More...
 
class  el::base::threading::internal::NoMutex
 Mutex wrapper used when multi-threading is disabled. More...
 
class  el::base::threading::internal::NoScopedLock< Mutex >
 Lock guard wrapper used when multi-threading is disabled. 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::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::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::PerformanceTrackingData
 
class  el::base::PerformanceTracker
 Represents performanceTracker block of code that conditionally adds performance status to log either when goes outside the scope of when checkpoint() is called. More...
 
class  el::base::DefaultPerformanceTrackingCallback
 
class  el::base::debug::StackTrace
 
class  el::base::debug::StackTrace::StackTraceEntry
 
class  el::base::debug::CrashHandler
 Handles unexpected crashes. More...
 
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++.
 
 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_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_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   1
 
#define ELPP_FINAL
 
#define ELPP_ASYNC_LOGGING   0
 
#define ELPP_FUNC   ""
 
#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 ELPP_LITERAL(txt)   txt
 
#define ELPP_STRLEN   strlen
 
#define ELPP_COUT   std::cout
 
#define ELPP_COUT_LINE(logLine)   logLine << std::flush
 
#define ELPP_INITI_BASIC_DECLR
 
#define ELPP   el::base::elStorage
 
#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, __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 ELPP_CURR_FILE_PERFORMANCE_LOGGER   el::base::consts::kPerformanceLoggerId
 
#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(obj, blockname)   el::base::PerformanceTracker obj(blockname, ELPP_MIN_UNIT)
 Performance tracked scope. Performance gets written when goes out of scope using 'performance' logger. More...
 
#define TIMED_BLOCK(obj, blockName)
 
#define TIMED_FUNC(obj)   TIMED_SCOPE(obj, ELPP_FUNC)
 Performance tracked function. Performance gets written when goes out of scope using 'performance' logger. More...
 
#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 DLOG(LEVEL)   DCLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
 
#define DVLOG(vlevel)   DCVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID)
 
#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)
 
#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)
 
#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)
 
#define CCHECK_NOTNULL(ptr,...)   el::base::utils::checkNotNull(ptr, #ptr, __VA_ARGS__)
 
#define CCHECK_STREQ(str1, str2,...)
 
#define CCHECK_STRNE(str1, str2,...)
 
#define CCHECK_STRCASEEQ(str1, str2,...)
 
#define CCHECK_STRCASENE(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)
 
#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)
 
#define ELPP_USE_DEF_CRASH_HANDLER   true
 
#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)
 

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, 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, 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::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::MillisecondsWidth = 32, el::ConfigurationType::PerformanceTracking = 64, el::ConfigurationType::MaxLogFileSize = 128,
  el::ConfigurationType::LogFlushThreshold = 256, el::ConfigurationType::Unknown = 1010, el::ConfigurationType::Enabled = 1, el::ConfigurationType::ToFile = 2,
  el::ConfigurationType::ToStandardOutput = 4, el::ConfigurationType::Format = 8, el::ConfigurationType::Filename = 16, el::ConfigurationType::MillisecondsWidth = 32,
  el::ConfigurationType::PerformanceTracking = 64, el::ConfigurationType::MaxLogFileSize = 128, el::ConfigurationType::LogFlushThreshold = 256, el::ConfigurationType::Unknown = 1010,
  el::ConfigurationType::Enabled = 1, el::ConfigurationType::ToFile = 2, el::ConfigurationType::ToStandardOutput = 4, el::ConfigurationType::Format = 8,
  el::ConfigurationType::Filename = 16, el::ConfigurationType::MillisecondsWidth = 32, 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::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::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
}
 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, 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,
  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, 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, 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::None = 1,
  el::base::DispatchAction::NormalLog = 2, el::base::DispatchAction::SysLog = 4, el::base::DispatchAction::None = 1, el::base::DispatchAction::NormalLog = 2,
  el::base::DispatchAction::SysLog = 4
}
 Action to be taken for dispatching. More...
 

Macro Definition Documentation

#define CCHECK (   condition,
  ... 
)    CLOG_IF(!(condition), FATAL, __VA_ARGS__) << "Check failed: [" << #condition << "] "
#define CCHECK_BOUNDS (   val,
  min,
  max,
  ... 
)    CCHECK(val >= min && val <= max, __VA_ARGS__)
#define CCHECK_EQ (   a,
  b,
  ... 
)    CCHECK(a == b, __VA_ARGS__)
#define CCHECK_GE (   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_LT (   a,
  b,
  ... 
)    CCHECK(a < b, __VA_ARGS__)
#define CCHECK_NE (   a,
  b,
  ... 
)    CCHECK(a != b, __VA_ARGS__)
#define CCHECK_NOTNULL (   ptr,
  ... 
)    el::base::utils::checkNotNull(ptr, #ptr, __VA_ARGS__)
#define CCHECK_STRCASEEQ (   str1,
  str2,
  ... 
)
Value:
CLOG_IF(!el::base::utils::Str::cStringCaseEq(str1, str2), FATAL, __VA_ARGS__) \
<< "Check failed: [" << #str1 << " == " << #str2 << "] "
#define CLOG_IF(condition, LEVEL,...)
Definition: easylogging++.h:6299
static bool cStringCaseEq(const char *s1, const char *s2)
Compares cstring equality (case-insensitive) - uses toupper(char) Dont use strcasecmp because of CRT ...
Definition: easylogging++.h:1353
#define CCHECK_STRCASENE (   str1,
  str2,
  ... 
)
Value:
CLOG_IF(el::base::utils::Str::cStringCaseEq(str1, str2), FATAL, __VA_ARGS__) \
<< "Check failed: [" << #str1 << " != " << #str2 << "] "
#define CLOG_IF(condition, LEVEL,...)
Definition: easylogging++.h:6299
static bool cStringCaseEq(const char *s1, const char *s2)
Compares cstring equality (case-insensitive) - uses toupper(char) Dont use strcasecmp because of CRT ...
Definition: easylogging++.h:1353
#define CCHECK_STREQ (   str1,
  str2,
  ... 
)
Value:
CLOG_IF(!el::base::utils::Str::cStringEq(str1, str2), FATAL, __VA_ARGS__) \
<< "Check failed: [" << #str1 << " == " << #str2 << "] "
#define CLOG_IF(condition, LEVEL,...)
Definition: easylogging++.h:6299
static bool cStringEq(const char *s1, const char *s2)
Compares cstring equality - uses strcmp.
Definition: easylogging++.h:1345
#define CCHECK_STRNE (   str1,
  str2,
  ... 
)
Value:
CLOG_IF(el::base::utils::Str::cStringEq(str1, str2), FATAL, __VA_ARGS__) \
<< "Check failed: [" << #str1 << " != " << #str2 << "] "
#define CLOG_IF(condition, LEVEL,...)
Definition: easylogging++.h:6299
static bool cStringEq(const char *s1, const char *s2)
Compares cstring equality - uses strcmp.
Definition: easylogging++.h:1345
#define CDEBUG (   writer,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG(writer, el::Level::Debug, dispatchAction, __VA_ARGS__)
#define CDEBUG_AFTER_N (   writer,
  n,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__)
#define CDEBUG_EVERY_N (   writer,
  occasion,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Debug, dispatchAction, __VA_ARGS__)
#define CDEBUG_IF (   writer,
  condition_,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Debug, 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 (   writer,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG(writer, el::Level::Error, dispatchAction, __VA_ARGS__)
#define CERROR_AFTER_N (   writer,
  n,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__)
#define CERROR_EVERY_N (   writer,
  occasion,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Error, dispatchAction, __VA_ARGS__)
#define CERROR_IF (   writer,
  condition_,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Error, 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 (   writer,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG(writer, el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define CFATAL_AFTER_N (   writer,
  n,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define CFATAL_EVERY_N (   writer,
  occasion,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define CFATAL_IF (   writer,
  condition_,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define CFATAL_N_TIMES (   writer,
  n,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__)
#define CHECK (   condition)    CCHECK(condition, ELPP_CURR_FILE_LOGGER_ID)
#define CHECK_BOUNDS (   val,
  min,
  max 
)    CCHECK_BOUNDS(val, min, max, ELPP_CURR_FILE_LOGGER_ID)
#define CHECK_EQ (   a,
 
)    CCHECK_EQ(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define CHECK_GE (   a,
 
)    CCHECK_GE(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define CHECK_GT (   a,
 
)    CCHECK_GT(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define CHECK_LE (   a,
 
)    CCHECK_LE(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define CHECK_LT (   a,
 
)    CCHECK_LT(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define CHECK_NE (   a,
 
)    CCHECK_NE(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define CHECK_NOTNULL (   ptr)    CCHECK_NOTNULL(ptr, 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)
#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 CINFO (   writer,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG(writer, el::Level::Info, dispatchAction, __VA_ARGS__)
#define CINFO_AFTER_N (   writer,
  n,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__)
#define CINFO_EVERY_N (   writer,
  occasion,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Info, dispatchAction, __VA_ARGS__)
#define CINFO_IF (   writer,
  condition_,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Info, dispatchAction, __VA_ARGS__)
#define CINFO_N_TIMES (   writer,
  n,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__)
#define CLOG (   LEVEL,
  ... 
)    C##LEVEL(el::base::Writer, 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 CLOG_EVERY_N (   n,
  LEVEL,
  ... 
)    C##LEVEL##_EVERY_N(el::base::Writer, n, 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 CLOG_N_TIMES (   n,
  LEVEL,
  ... 
)    C##LEVEL##_N_TIMES(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__)
#define CPCHECK (   condition,
  ... 
)    CPLOG_IF(!(condition), FATAL, __VA_ARGS__) << "Check failed: [" << #condition << "] "
#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 CSYSLOG (   LEVEL,
  ... 
)    el::base::NullWriter()
#define CSYSLOG_AFTER_N (   n,
  LEVEL,
  ... 
)    el::base::NullWriter()
#define CSYSLOG_EVERY_N (   n,
  LEVEL,
  ... 
)    el::base::NullWriter()
#define CSYSLOG_IF (   condition,
  LEVEL,
  ... 
)    el::base::NullWriter()
#define CSYSLOG_N_TIMES (   n,
  LEVEL,
  ... 
)    el::base::NullWriter()
#define CTRACE (   writer,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG(writer, el::Level::Trace, dispatchAction, __VA_ARGS__)
#define CTRACE_AFTER_N (   writer,
  n,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__)
#define CTRACE_EVERY_N (   writer,
  occasion,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Trace, dispatchAction, __VA_ARGS__)
#define CTRACE_IF (   writer,
  condition_,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Trace, 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 (   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__)
Information that can be highly useful and vary with verbose logging level.
#define ELPP_FUNC
Definition: easylogging++.h:239
#define el_getVALength(...)
Definition: easylogging++.h:5216
#define VLOG_IS_ON(verboseLevel)
Determines whether verbose logging is on for specified level current file.
Definition: easylogging++.h:5988
#define CVERBOSE_AFTER_N (   writer,
  n,
  vlevel,
  dispatchAction,
  ... 
)    CVERBOSE_IF(writer, ELPP->validateAfterNCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__)
#define CVERBOSE_EVERY_N (   writer,
  occasion,
  vlevel,
  dispatchAction,
  ... 
)    CVERBOSE_IF(writer, ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion), vlevel, dispatchAction, __VA_ARGS__)
#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__)
Information that can be highly useful and vary with verbose logging level.
#define ELPP_FUNC
Definition: easylogging++.h:239
#define el_getVALength(...)
Definition: easylogging++.h:5216
#define VLOG_IS_ON(verboseLevel)
Determines whether verbose logging is on for specified level current file.
Definition: easylogging++.h:5988
#define CVERBOSE_N_TIMES (   writer,
  n,
  vlevel,
  dispatchAction,
  ... 
)    CVERBOSE_IF(writer, ELPP->validateNTimesCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__)
#define CVLOG (   vlevel,
  ... 
)    CVERBOSE(el::base::Writer, vlevel, 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 CVLOG_EVERY_N (   n,
  vlevel,
  ... 
)    CVERBOSE_EVERY_N(el::base::Writer, n, vlevel, 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 CVLOG_N_TIMES (   n,
  vlevel,
  ... 
)    CVERBOSE_N_TIMES(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
#define CWARNING (   writer,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG(writer, el::Level::Warning, dispatchAction, __VA_ARGS__)
#define CWARNING_AFTER_N (   writer,
  n,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__)
#define CWARNING_EVERY_N (   writer,
  occasion,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Warning, dispatchAction, __VA_ARGS__)
#define CWARNING_IF (   writer,
  condition_,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Warning, dispatchAction, __VA_ARGS__)
#define CWARNING_N_TIMES (   writer,
  n,
  dispatchAction,
  ... 
)    ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__)
#define DCCHECK (   condition,
  ... 
)    if (ELPP_DEBUG_LOG) CCHECK(condition, __VA_ARGS__)
#define DCCHECK_BOUNDS (   val,
  min,
  max,
  ... 
)    if (ELPP_DEBUG_LOG) CCHECK_BOUNDS(val, min, max, __VA_ARGS__)
#define DCCHECK_EQ (   a,
  b,
  ... 
)    if (ELPP_DEBUG_LOG) CCHECK_EQ(a, b, __VA_ARGS__)
#define DCCHECK_GE (   a,
  b,
  ... 
)    if (ELPP_DEBUG_LOG) CCHECK_GE(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_LT (   a,
  b,
  ... 
)    if (ELPP_DEBUG_LOG) CCHECK_LT(a, b, __VA_ARGS__)
#define DCCHECK_NE (   a,
  b,
  ... 
)    if (ELPP_DEBUG_LOG) CCHECK_NE(a, b, __VA_ARGS__)
#define DCCHECK_NOTNULL (   ptr,
  ... 
)    if (ELPP_DEBUG_LOG) CCHECK_NOTNULL(ptr, __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 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 DCHECK (   condition)    DCCHECK(condition, ELPP_CURR_FILE_LOGGER_ID)
#define DCHECK_BOUNDS (   val,
  min,
  max 
)    DCCHECK_BOUNDS(val, min, max, ELPP_CURR_FILE_LOGGER_ID)
#define DCHECK_EQ (   a,
 
)    DCCHECK_EQ(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define DCHECK_GE (   a,
 
)    DCCHECK_GE(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define DCHECK_GT (   a,
 
)    DCCHECK_GT(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define DCHECK_LE (   a,
 
)    DCCHECK_LE(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define DCHECK_LT (   a,
 
)    DCCHECK_LT(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define DCHECK_NE (   a,
 
)    DCCHECK_NE(a, b, ELPP_CURR_FILE_LOGGER_ID)
#define DCHECK_NOTNULL (   ptr)    DCCHECK_NOTNULL(ptr, 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 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 DCLOG (   LEVEL,
  ... 
)    if (ELPP_DEBUG_LOG) CLOG(LEVEL, __VA_ARGS__)
#define DCLOG_AFTER_N (   n,
  LEVEL,
  ... 
)    if (ELPP_DEBUG_LOG) CLOG_AFTER_N(n, LEVEL, __VA_ARGS__)
#define DCLOG_EVERY_N (   n,
  LEVEL,
  ... 
)    if (ELPP_DEBUG_LOG) CLOG_EVERY_N(n, LEVEL, __VA_ARGS__)
#define DCLOG_IF (   condition,
  LEVEL,
  ... 
)    if (ELPP_DEBUG_LOG) CLOG_IF(condition, LEVEL, __VA_ARGS__)
#define DCLOG_N_TIMES (   n,
  LEVEL,
  ... 
)    if (ELPP_DEBUG_LOG) CLOG_N_TIMES(n, LEVEL, __VA_ARGS__)
#define DCLOG_VERBOSE (   vlevel,
  ... 
)    if (ELPP_DEBUG_LOG) CLOG_VERBOSE(vlevel, __VA_ARGS__)
#define DCPCHECK (   condition,
  ... 
)    if (ELPP_DEBUG_LOG) CPCHECK(condition, __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 DCSYSLOG (   LEVEL,
  ... 
)    el::base::NullWriter()
#define DCSYSLOG_AFTER_N (   n,
  LEVEL,
  ... 
)    el::base::NullWriter()
#define DCSYSLOG_EVERY_N (   n,
  LEVEL,
  ... 
)    el::base::NullWriter()
#define DCSYSLOG_IF (   condition,
  LEVEL,
  ... 
)    el::base::NullWriter()
#define DCSYSLOG_N_TIMES (   n,
  LEVEL,
  ... 
)    el::base::NullWriter()
#define DCVLOG (   vlevel,
  ... 
)    if (ELPP_DEBUG_LOG) CVLOG(vlevel, __VA_ARGS__)
#define DCVLOG_AFTER_N (   n,
  vlevel,
  ... 
)    if (ELPP_DEBUG_LOG) CVLOG_AFTER_N(n, vlevel, __VA_ARGS__)
#define DCVLOG_EVERY_N (   n,
  vlevel,
  ... 
)    if (ELPP_DEBUG_LOG) CVLOG_EVERY_N(n, vlevel, __VA_ARGS__)
#define DCVLOG_IF (   condition,
  vlevel,
  ... 
)    if (ELPP_DEBUG_LOG) CVLOG_IF(condition, vlevel, __VA_ARGS__)
#define DCVLOG_N_TIMES (   n,
  vlevel,
  ... 
)    if (ELPP_DEBUG_LOG) CVLOG_N_TIMES(n, vlevel, __VA_ARGS__)
#define DLOG (   LEVEL)    DCLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define DLOG_AFTER_N (   n,
  LEVEL 
)    DCLOG_AFTER_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define DLOG_EVERY_N (   n,
  LEVEL 
)    DCLOG_EVERY_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define DLOG_IF (   condition,
  LEVEL 
)    DCLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define DLOG_N_TIMES (   n,
  LEVEL 
)    DCLOG_N_TIMES(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define DPCHECK (   condition)    DCPCHECK(condition, 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 DSYSLOG (   LEVEL)    el::base::NullWriter()
#define DSYSLOG_AFTER_N (   n,
  LEVEL 
)    el::base::NullWriter()
#define DSYSLOG_EVERY_N (   n,
  LEVEL 
)    el::base::NullWriter()
#define DSYSLOG_IF (   condition,
  LEVEL 
)    el::base::NullWriter()
#define DSYSLOG_N_TIMES (   n,
  LEVEL 
)    el::base::NullWriter()
#define DVLOG (   vlevel)    DCVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID)
#define DVLOG_AFTER_N (   n,
  vlevel 
)    DCVLOG_AFTER_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
#define DVLOG_EVERY_N (   n,
  vlevel 
)    DCVLOG_EVERY_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
#define DVLOG_IF (   condition,
  vlevel 
)    DCVLOG_IF(condition, vlevel, ELPP_CURR_FILE_LOGGER_ID)
#define DVLOG_N_TIMES (   n,
  vlevel 
)    DCVLOG_N_TIMES(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
#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   el::base::elStorage
#define ELPP_ASSERT (   expr,
  msg 
)
Value:
if (!(expr)) { \
std::stringstream internalInfoStream; internalInfoStream << msg; \
<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \
<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \
optional string msg
Definition: topics.proto:7
#define ELPP_INTERNAL_DEBUGGING_OUT_ERROR
Definition: easylogging++.h:102
#define ELPP_INTERNAL_DEBUGGING_MSG(msg)
Definition: easylogging++.h:108
#define ELPP_INTERNAL_DEBUGGING_ENDL
Definition: easylogging++.h:105
#define ELPP_ASYNC_LOGGING   0
#define ELPP_COUNTER   (ELPP->hitCounters()->getCounter(__FILE__, __LINE__))

Gets hit counter for file/line.

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

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

#define ELPP_COUT   std::cout
#define ELPP_COUT_LINE (   logLine)    logLine << std::flush
#define ELPP_CRASH_HANDLER_INIT
#define ELPP_CURR_FILE_LOGGER_ID   el::base::consts::kDefaultLoggerId
#define ELPP_CURR_FILE_PERFORMANCE_LOGGER   el::base::consts::kPerformanceLoggerId
#define ELPP_DEBUG_LOG   1
#define ELPP_ERROR_LOG   1
#define ELPP_EXPORT
#define ELPP_FATAL_LOG   1
#define ELPP_FINAL
#define ELPP_FUNC   ""
#define ELPP_INFO_LOG   1
#define ELPP_INIT_EASYLOGGINGPP (   val)
Value:
ELPP_INITI_BASIC_DECLR\
namespace el {\
namespace base {\
}\
el::base::debug::CrashHandler elCrashHandler(false);\
}
ELPP_EXPORT base::type::StoragePointer elStorage
Definition: easylogging++.h:4166
std::shared_ptr< base::Storage > StoragePointer
Definition: easylogging++.h:472
base::debug::CrashHandler elCrashHandler
Definition: easylogging++.h:5625
#define ELPP_INITI_BASIC_DECLR
Value:
namespace el {\
namespace base {\
namespace utils {\
}\
}\
}
static bool termSupportsColor(void)
Whether or not terminal supports colors.
Definition: easylogging++.h:1542
std::string s_currentHost
Definition: easylogging++.h:1549
static std::string currentUser(void)
Gets current username.
Definition: easylogging++.h:1513
std::string s_currentUser
Definition: easylogging++.h:1548
static std::string currentHost(void)
Gets current host name or computer name.
Definition: easylogging++.h:1529
bool s_termSupportsColor
Definition: easylogging++.h:1550
#define ELPP_INITIALIZE_SYSLOG (   id,
  opt,
  fac 
)    el::SysLogInitializer elSyslogInit(id, opt, fac)
#define ELPP_INTERNAL_DEBUGGING_ENDL   std::endl
#define ELPP_INTERNAL_DEBUGGING_MSG (   msg)    msg
#define ELPP_INTERNAL_DEBUGGING_OUT_ERROR   std::cerr
#define ELPP_INTERNAL_DEBUGGING_OUT_INFO   std::cout
#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_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()); \
}
#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()); \
}
#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()); \
}
#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()); \
}
#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()); \
}
#define ELPP_LITERAL (   txt)    txt
#define ELPP_LOGGING_ENABLED   1
#define ELPP_MIN_UNIT   el::base::TimestampUnit::Millisecond
#define ELPP_SIMPLE_LOG (   LOG_TYPE)
Value:
inline MessageBuilder& operator<<(LOG_TYPE msg) {\
m_logger->stream() << msg;\
if (ELPP->hasFlag(LoggingFlag::AutoSpacing)) {\
m_logger->stream() << " ";\
}\
return *this;\
}
optional string msg
Definition: topics.proto:7
QDebug operator<<(QDebug d, const QCPVector2D &vec)
Definition: qcustomplot.h:444
#define ELPP
Definition: easylogging++.h:4167
#define ELPP_STRLEN   strlen
#define ELPP_TRACE   CLOG(TRACE, ELPP_CURR_FILE_LOGGER_ID)
#define ELPP_TRACE_LOG   1
#define ELPP_UNUSED (   x)    (void)x
#define ELPP_USE_DEF_CRASH_HANDLER   true
#define ELPP_USE_STD_THREADING   1
#define ELPP_VERBOSE_LOG   1
#define ELPP_WARNING_LOG   1
#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_AFTER_N (   writer,
  n,
  level,
  dispatchAction,
  ... 
)
Value:
if (ELPP->validateAfterNCounter(__FILE__, __LINE__, n)) \
writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
#define ELPP_FUNC
Definition: easylogging++.h:239
#define el_getVALength(...)
Definition: easylogging++.h:5216
#define ELPP
Definition: easylogging++.h:4167
#define ELPP_WRITE_LOG_EVERY_N (   writer,
  occasion,
  level,
  dispatchAction,
  ... 
)
Value:
if (ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion)) \
writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
#define ELPP_FUNC
Definition: easylogging++.h:239
#define el_getVALength(...)
Definition: easylogging++.h:5216
#define ELPP
Definition: easylogging++.h:4167
#define ELPP_WRITE_LOG_IF (   writer,
  condition,
  level,
  dispatchAction,
  ... 
)
Value:
if (condition) \
writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
#define ELPP_FUNC
Definition: easylogging++.h:239
#define el_getVALength(...)
Definition: easylogging++.h:5216
#define ELPP_WRITE_LOG_N_TIMES (   writer,
  n,
  level,
  dispatchAction,
  ... 
)
Value:
if (ELPP->validateNTimesCounter(__FILE__, __LINE__, n)) \
writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
#define ELPP_FUNC
Definition: easylogging++.h:239
#define el_getVALength(...)
Definition: easylogging++.h:5216
#define ELPP
Definition: easylogging++.h:4167
#define ELPP_WX_ENABLED (   ContainerType)
#define ELPP_WX_HASH_MAP_ENABLED (   ContainerType)
#define ELPP_WX_PTR_ENABLED (   ContainerType)
#define INITIALIZE_EASYLOGGINGPP   ELPP_INIT_EASYLOGGINGPP(new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder())))
#define INITIALIZE_NULL_EASYLOGGINGPP
Value:
ELPP_INITI_BASIC_DECLR\
namespace el {\
namespace base {\
}\
el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\
}
ELPP_EXPORT base::type::StoragePointer elStorage
Definition: easylogging++.h:4166
std::shared_ptr< base::Storage > StoragePointer
Definition: easylogging++.h:472
base::debug::CrashHandler elCrashHandler
Definition: easylogging++.h:5625
#define ELPP_USE_DEF_CRASH_HANDLER
Definition: easylogging++.h:6620
#define LOG (   LEVEL)    CLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define LOG_AFTER_N (   n,
  LEVEL 
)    CLOG_AFTER_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define LOG_EVERY_N (   n,
  LEVEL 
)    CLOG_EVERY_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define LOG_IF (   condition,
  LEVEL 
)    CLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define LOG_N_TIMES (   n,
  LEVEL 
)    CLOG_N_TIMES(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
#define MAKE_CONTAINERELPP_FRIENDLY (   ContainerType,
  SizeMethod,
  ElementInstance 
)
Value:
el::base::type::ostream_t& operator<<(el::base::type::ostream_t& ss, const ContainerType& container) {\
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;\
}
char char_t
Definition: easylogging++.h:460
#define ELPP_LITERAL(txt)
Definition: easylogging++.h:453
std::ostream ostream_t
Definition: easylogging++.h:464
Makes sure we have new line for each container log entry.
QDebug operator<<(QDebug d, const QCPVector2D &vec)
Definition: qcustomplot.h:444
#define ELPP
Definition: easylogging++.h:4167
std::string const
Definition: Test{{cookiecutter.device_name}}.cpp:209

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
ContainerTypeType of container e.g, MyList from WX_DECLARE_LIST(int, MyList); in wxwidgets
SizeMethodMethod used to get size of container.
ElementInstanceInstance of element to be fed out. Insance name is "elem". See WXELPP_ENABLED macro for an example usage
#define MAKE_LOGGABLE (   ClassType,
  ClassInstance,
  OutputStreamInstance 
)    el::base::type::ostream_t& operator<<(el::base::type::ostream_t& OutputStreamInstance, const ClassType& ClassInstance)
#define PCHECK (   condition)    CPCHECK(condition, ELPP_CURR_FILE_LOGGER_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)
#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 SHARE_EASYLOGGINGPP (   initializedStorage)
Value:
namespace el {\
namespace base {\
}\
el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\
}
ELPP_EXPORT base::type::StoragePointer elStorage
Definition: easylogging++.h:4166
std::shared_ptr< base::Storage > StoragePointer
Definition: easylogging++.h:472
base::debug::CrashHandler elCrashHandler
Definition: easylogging++.h:5625
#define ELPP_USE_DEF_CRASH_HANDLER
Definition: easylogging++.h:6620
#define START_EASYLOGGINGPP (   argc,
  argv 
)    el::Helpers::setArgs(argc, argv)
#define STRCAT (   a,
  b,
  len 
)    strcat(a, b)
#define STRCPY (   a,
  b,
  len 
)    strcpy(a, b)
#define STRERROR (   a,
  b,
 
)    strerror(c)
#define STRTOK (   a,
  b,
 
)    strtok(a, b)
#define SYSLOG (   LEVEL)    el::base::NullWriter()
#define SYSLOG_AFTER_N (   n,
  LEVEL 
)    el::base::NullWriter()
#define SYSLOG_EVERY_N (   n,
  LEVEL 
)    el::base::NullWriter()
#define SYSLOG_IF (   condition,
  LEVEL 
)    el::base::NullWriter()
#define SYSLOG_N_TIMES (   n,
  LEVEL 
)    el::base::NullWriter()
#define TIMED_BLOCK (   obj,
  blockName 
)
Value:
for (struct { int i; el::base::PerformanceTracker timer; } obj = { 0, \
el::base::PerformanceTracker(blockName, ELPP_MIN_UNIT) }; obj.i < 1; ++obj.i)
#define ELPP_MIN_UNIT
Definition: easylogging++.h:5996
Represents performanceTracker block of code that conditionally adds performance status to log either ...
Definition: easylogging++.h:5279
#define TIMED_FUNC (   obj)    TIMED_SCOPE(obj, ELPP_FUNC)

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
#define TIMED_SCOPE (   obj,
  blockname 
)    el::base::PerformanceTracker obj(blockname, ELPP_MIN_UNIT)

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
#define VLOG (   vlevel)    CVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID)
#define VLOG_AFTER_N (   n,
  vlevel 
)    CVLOG_AFTER_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
#define VLOG_EVERY_N (   n,
  vlevel 
)    CVLOG_EVERY_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
#define VLOG_IF (   condition,
  vlevel 
)    CVLOG_IF(condition, vlevel, ELPP_CURR_FILE_LOGGER_ID)
#define VLOG_IS_ON (   verboseLevel)    (ELPP->vRegistry()->allowed(verboseLevel, __FILE__))

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

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