Monero
Loading...
Searching...
No Matches
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions | Variables
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::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::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::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

namespace  el
 Easylogging++ entry namespace.
namespace  el::base
 Namespace containing base/internal functionality used by Easylogging++.
namespace  el::base::type
 Data types used by Easylogging++.
namespace  std
namespace  el::base::consts
 Namespace containing constants used internally.
namespace  el::base::utils
 Namespace containing utility functions/static classes used internally.
namespace  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.
namespace  el::base::threading
namespace  el::base::threading::internal
namespace  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)
#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)
#define ELPP_EXPORT
#define STRTOK(a, b, c)
#define STRERROR(a, b, c)
#define STRCAT(a, b, len)
#define STRCPY(a, b, len)
#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   0
#define ELPP_INFO_LOG   0
#define ELPP_WARNING_LOG   0
#define ELPP_ERROR_LOG   0
#define ELPP_FATAL_LOG   0
#define ELPP_TRACE_LOG   0
#define ELPP_VERBOSE_LOG   0
#define elpptime_r   gmtime_r
#define elpptime_s   gmtime_s
#define elpptime   gmtime
#define ELPP_LITERAL(txt)
#define ELPP_STRLEN   strlen
#define ELPP_COUT   std::cout
#define ELPP_COUT_LINE(logLine)
#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.
#define ELPP_WX_PTR_ENABLED(ContainerType)
#define ELPP_WX_ENABLED(ContainerType)
#define ELPP_WX_HASH_MAP_ENABLED(ContainerType)
#define el_getVALength(...)
#define el_resolveVALength(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...)
#define ELPP_WRITE_LOG(writer, level, dispatchAction, ...)
#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)
#define ELPP_INITIALIZE_SYSLOG(id, opt, fac)
#define VLOG_IS_ON(verboseLevel)
 Determines whether verbose logging is on for specified level current file.
#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.
#define TIMED_SCOPE(obj, blockname)
#define TIMED_BLOCK(obj, blockName)
#define TIMED_FUNC_IF(obj, condition)
 Performance tracked function. Performance gets written when goes out of scope using 'performance' logger.
#define TIMED_FUNC(obj)
#define PERFORMANCE_CHECKPOINT(obj)
#define PERFORMANCE_CHECKPOINT_WITH_ID(obj, id)
#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 CINFO(writer, dispatchAction, ...)
#define CWARNING(writer, dispatchAction, ...)
#define CDEBUG(writer, dispatchAction, ...)
#define CERROR(writer, dispatchAction, ...)
#define CFATAL(writer, dispatchAction, ...)
#define CTRACE(writer, dispatchAction, ...)
#define CVERBOSE(writer, vlevel, dispatchAction, ...)
#define CINFO_IF(writer, condition_, dispatchAction, ...)
#define CWARNING_IF(writer, condition_, dispatchAction, ...)
#define CDEBUG_IF(writer, condition_, dispatchAction, ...)
#define CERROR_IF(writer, condition_, dispatchAction, ...)
#define CFATAL_IF(writer, condition_, dispatchAction, ...)
#define CTRACE_IF(writer, condition_, dispatchAction, ...)
#define CVERBOSE_IF(writer, condition_, vlevel, dispatchAction, ...)
#define CINFO_EVERY_N(writer, occasion, dispatchAction, ...)
#define CWARNING_EVERY_N(writer, occasion, dispatchAction, ...)
#define CDEBUG_EVERY_N(writer, occasion, dispatchAction, ...)
#define CERROR_EVERY_N(writer, occasion, dispatchAction, ...)
#define CFATAL_EVERY_N(writer, occasion, dispatchAction, ...)
#define CTRACE_EVERY_N(writer, occasion, dispatchAction, ...)
#define CVERBOSE_EVERY_N(writer, occasion, vlevel, dispatchAction, ...)
#define CINFO_AFTER_N(writer, n, dispatchAction, ...)
#define CWARNING_AFTER_N(writer, n, dispatchAction, ...)
#define CDEBUG_AFTER_N(writer, n, dispatchAction, ...)
#define CERROR_AFTER_N(writer, n, dispatchAction, ...)
#define CFATAL_AFTER_N(writer, n, dispatchAction, ...)
#define CTRACE_AFTER_N(writer, n, dispatchAction, ...)
#define CVERBOSE_AFTER_N(writer, n, vlevel, dispatchAction, ...)
#define CINFO_N_TIMES(writer, n, dispatchAction, ...)
#define CWARNING_N_TIMES(writer, n, dispatchAction, ...)
#define CDEBUG_N_TIMES(writer, n, dispatchAction, ...)
#define CERROR_N_TIMES(writer, n, dispatchAction, ...)
#define CFATAL_N_TIMES(writer, n, dispatchAction, ...)
#define CTRACE_N_TIMES(writer, n, dispatchAction, ...)
#define CVERBOSE_N_TIMES(writer, n, vlevel, dispatchAction, ...)
#define CLOG(LEVEL, ...)
#define CVLOG(vlevel, ...)
#define CLOG_IF(condition, LEVEL, ...)
#define CVLOG_IF(condition, vlevel, ...)
#define CLOG_EVERY_N(n, LEVEL, ...)
#define CVLOG_EVERY_N(n, vlevel, ...)
#define CLOG_AFTER_N(n, LEVEL, ...)
#define CVLOG_AFTER_N(n, vlevel, ...)
#define CLOG_N_TIMES(n, LEVEL, ...)
#define CVLOG_N_TIMES(n, vlevel, ...)
#define ELPP_CURR_FILE_LOGGER_ID   el::base::consts::kDefaultLoggerId
#define ELPP_TRACE   CLOG(TRACE, ELPP_CURR_FILE_LOGGER_ID)
#define LOG(LEVEL)
#define VLOG(vlevel)
#define LOG_IF(condition, LEVEL)
#define VLOG_IF(condition, vlevel)
#define LOG_EVERY_N(n, LEVEL)
#define VLOG_EVERY_N(n, vlevel)
#define LOG_AFTER_N(n, LEVEL)
#define VLOG_AFTER_N(n, vlevel)
#define LOG_N_TIMES(n, LEVEL)
#define VLOG_N_TIMES(n, vlevel)
#define CPLOG(LEVEL, ...)
#define CPLOG_IF(condition, LEVEL, ...)
#define DCPLOG(LEVEL, ...)
#define DCPLOG_IF(condition, LEVEL, ...)
#define PLOG(LEVEL)
#define PLOG_IF(condition, LEVEL)
#define DPLOG(LEVEL)
#define DPLOG_IF(condition, LEVEL)
#define CSYSLOG(LEVEL, ...)
#define CSYSLOG_IF(condition, LEVEL, ...)
#define CSYSLOG_EVERY_N(n, LEVEL, ...)
#define CSYSLOG_AFTER_N(n, LEVEL, ...)
#define CSYSLOG_N_TIMES(n, LEVEL, ...)
#define SYSLOG(LEVEL)
#define SYSLOG_IF(condition, LEVEL)
#define SYSLOG_EVERY_N(n, LEVEL)
#define SYSLOG_AFTER_N(n, LEVEL)
#define SYSLOG_N_TIMES(n, LEVEL)
#define DCSYSLOG(LEVEL, ...)
#define DCSYSLOG_IF(condition, LEVEL, ...)
#define DCSYSLOG_EVERY_N(n, LEVEL, ...)
#define DCSYSLOG_AFTER_N(n, LEVEL, ...)
#define DCSYSLOG_N_TIMES(n, LEVEL, ...)
#define DSYSLOG(LEVEL)
#define DSYSLOG_IF(condition, LEVEL)
#define DSYSLOG_EVERY_N(n, LEVEL)
#define DSYSLOG_AFTER_N(n, LEVEL)
#define DSYSLOG_N_TIMES(n, LEVEL)
#define DCLOG(LEVEL, ...)
#define DCLOG_VERBOSE(vlevel, ...)
#define DCVLOG(vlevel, ...)
#define DCLOG_IF(condition, LEVEL, ...)
#define DCVLOG_IF(condition, vlevel, ...)
#define DCLOG_EVERY_N(n, LEVEL, ...)
#define DCVLOG_EVERY_N(n, vlevel, ...)
#define DCLOG_AFTER_N(n, LEVEL, ...)
#define DCVLOG_AFTER_N(n, vlevel, ...)
#define DCLOG_N_TIMES(n, LEVEL, ...)
#define DCVLOG_N_TIMES(n, vlevel, ...)
#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)

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

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,
... )
Value:
el::base::NullWriter()
el::base::NullWriter
Writes nothing - Used when certain log is disabled.
Definition easylogging++.h:3240

◆ CDEBUG_AFTER_N

#define CDEBUG_AFTER_N ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CDEBUG_EVERY_N

#define CDEBUG_EVERY_N ( writer,
occasion,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CDEBUG_IF

#define CDEBUG_IF ( writer,
condition_,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CDEBUG_N_TIMES

#define CDEBUG_N_TIMES ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CERROR

#define CERROR ( writer,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CERROR_AFTER_N

#define CERROR_AFTER_N ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CERROR_EVERY_N

#define CERROR_EVERY_N ( writer,
occasion,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CERROR_IF

#define CERROR_IF ( writer,
condition_,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CERROR_N_TIMES

#define CERROR_N_TIMES ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CFATAL

#define CFATAL ( writer,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CFATAL_AFTER_N

#define CFATAL_AFTER_N ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CFATAL_EVERY_N

#define CFATAL_EVERY_N ( writer,
occasion,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CFATAL_IF

#define CFATAL_IF ( writer,
condition_,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CFATAL_N_TIMES

#define CFATAL_N_TIMES ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CINFO

#define CINFO ( writer,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CINFO_AFTER_N

#define CINFO_AFTER_N ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CINFO_EVERY_N

#define CINFO_EVERY_N ( writer,
occasion,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CINFO_IF

#define CINFO_IF ( writer,
condition_,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CINFO_N_TIMES

#define CINFO_N_TIMES ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CLOG

#define CLOG ( LEVEL,
... )
Value:
C##LEVEL(el::base::Writer, el::base::DispatchAction::NormalLog, __VA_ARGS__)
el::base::Writer
Main entry point of each logging.
Definition easylogging++.h:3259
el::base::DispatchAction::NormalLog
@ NormalLog
Definition easylogging++.h:2180

◆ CLOG_AFTER_N

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

◆ CLOG_EVERY_N

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

◆ CLOG_IF

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

◆ CLOG_N_TIMES

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

◆ CPLOG

#define CPLOG ( LEVEL,
... )
Value:
C##LEVEL(el::base::PErrorWriter, el::base::DispatchAction::NormalLog, __VA_ARGS__)
el::base::PErrorWriter
Definition easylogging++.h:3314

◆ CPLOG_IF

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

◆ CSYSLOG

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

◆ CSYSLOG_AFTER_N

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

◆ CSYSLOG_EVERY_N

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

◆ CSYSLOG_IF

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

◆ CSYSLOG_N_TIMES

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

◆ CTRACE

#define CTRACE ( writer,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CTRACE_AFTER_N

#define CTRACE_AFTER_N ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CTRACE_EVERY_N

#define CTRACE_EVERY_N ( writer,
occasion,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CTRACE_IF

#define CTRACE_IF ( writer,
condition_,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CTRACE_N_TIMES

#define CTRACE_N_TIMES ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CVERBOSE

#define CVERBOSE ( writer,
vlevel,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CVERBOSE_AFTER_N

#define CVERBOSE_AFTER_N ( writer,
n,
vlevel,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CVERBOSE_EVERY_N

#define CVERBOSE_EVERY_N ( writer,
occasion,
vlevel,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CVERBOSE_IF

#define CVERBOSE_IF ( writer,
condition_,
vlevel,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CVERBOSE_N_TIMES

#define CVERBOSE_N_TIMES ( writer,
n,
vlevel,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CVLOG

#define CVLOG ( vlevel,
... )
Value:
CVERBOSE(el::base::Writer, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
CVERBOSE
#define CVERBOSE(writer, vlevel, dispatchAction,...)
Definition easylogging++.h:4101

◆ CVLOG_AFTER_N

#define CVLOG_AFTER_N ( n,
vlevel,
... )
Value:
CVERBOSE_AFTER_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
CVERBOSE_AFTER_N
#define CVERBOSE_AFTER_N(writer, n, vlevel, dispatchAction,...)
Definition easylogging++.h:4230

◆ CVLOG_EVERY_N

#define CVLOG_EVERY_N ( n,
vlevel,
... )
Value:
CVERBOSE_EVERY_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
CVERBOSE_EVERY_N
#define CVERBOSE_EVERY_N(writer, occasion, vlevel, dispatchAction,...)
Definition easylogging++.h:4187

◆ CVLOG_IF

#define CVLOG_IF ( condition,
vlevel,
... )
Value:
CVERBOSE_IF(el::base::Writer, condition, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
CVERBOSE_IF
#define CVERBOSE_IF(writer, condition_, vlevel, dispatchAction,...)
Definition easylogging++.h:4144

◆ CVLOG_N_TIMES

#define CVLOG_N_TIMES ( n,
vlevel,
... )
Value:
CVERBOSE_N_TIMES(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
CVERBOSE_N_TIMES
#define CVERBOSE_N_TIMES(writer, n, vlevel, dispatchAction,...)
Definition easylogging++.h:4273

◆ CWARNING

#define CWARNING ( writer,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CWARNING_AFTER_N

#define CWARNING_AFTER_N ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CWARNING_EVERY_N

#define CWARNING_EVERY_N ( writer,
occasion,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CWARNING_IF

#define CWARNING_IF ( writer,
condition_,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ CWARNING_N_TIMES

#define CWARNING_N_TIMES ( writer,
n,
dispatchAction,
... )
Value:
el::base::NullWriter()

◆ DCLOG

#define DCLOG ( LEVEL,
... )
Value:
if (ELPP_DEBUG_LOG) CLOG(LEVEL, __VA_ARGS__)
CLOG
#define CLOG(LEVEL,...)
Definition easylogging++.h:4292
ELPP_DEBUG_LOG
#define ELPP_DEBUG_LOG
Definition easylogging++.h:328

◆ DCLOG_AFTER_N

#define DCLOG_AFTER_N ( n,
LEVEL,
... )
Value:
if (ELPP_DEBUG_LOG) CLOG_AFTER_N(n, LEVEL, __VA_ARGS__)
CLOG_AFTER_N
#define CLOG_AFTER_N(n, LEVEL,...)
Definition easylogging++.h:4305

◆ DCLOG_EVERY_N

#define DCLOG_EVERY_N ( n,
LEVEL,
... )
Value:
if (ELPP_DEBUG_LOG) CLOG_EVERY_N(n, LEVEL, __VA_ARGS__)
CLOG_EVERY_N
#define CLOG_EVERY_N(n, LEVEL,...)
Definition easylogging++.h:4301

◆ DCLOG_IF

#define DCLOG_IF ( condition,
LEVEL,
... )
Value:
if (ELPP_DEBUG_LOG) CLOG_IF(condition, LEVEL, __VA_ARGS__)
CLOG_IF
#define CLOG_IF(condition, LEVEL,...)
Definition easylogging++.h:4296

◆ DCLOG_N_TIMES

#define DCLOG_N_TIMES ( n,
LEVEL,
... )
Value:
if (ELPP_DEBUG_LOG) CLOG_N_TIMES(n, LEVEL, __VA_ARGS__)
CLOG_N_TIMES
#define CLOG_N_TIMES(n, LEVEL,...)
Definition easylogging++.h:4309

◆ DCLOG_VERBOSE

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

◆ DCPLOG

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

◆ DCPLOG_IF

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

◆ DCSYSLOG

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

◆ DCSYSLOG_AFTER_N

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

◆ DCSYSLOG_EVERY_N

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

◆ DCSYSLOG_IF

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

◆ DCSYSLOG_N_TIMES

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

◆ DCVLOG

#define DCVLOG ( vlevel,
... )
Value:
if (ELPP_DEBUG_LOG) CVLOG(vlevel, __VA_ARGS__)
CVLOG
#define CVLOG(vlevel,...)
Definition easylogging++.h:4294

◆ DCVLOG_AFTER_N

#define DCVLOG_AFTER_N ( n,
vlevel,
... )
Value:
if (ELPP_DEBUG_LOG) CVLOG_AFTER_N(n, vlevel, __VA_ARGS__)
CVLOG_AFTER_N
#define CVLOG_AFTER_N(n, vlevel,...)
Definition easylogging++.h:4307

◆ DCVLOG_EVERY_N

#define DCVLOG_EVERY_N ( n,
vlevel,
... )
Value:
if (ELPP_DEBUG_LOG) CVLOG_EVERY_N(n, vlevel, __VA_ARGS__)
CVLOG_EVERY_N
#define CVLOG_EVERY_N(n, vlevel,...)
Definition easylogging++.h:4303

◆ DCVLOG_IF

#define DCVLOG_IF ( condition,
vlevel,
... )
Value:
if (ELPP_DEBUG_LOG) CVLOG_IF(condition, vlevel, __VA_ARGS__)
CVLOG_IF
#define CVLOG_IF(condition, vlevel,...)
Definition easylogging++.h:4298

◆ DCVLOG_N_TIMES

#define DCVLOG_N_TIMES ( n,
vlevel,
... )
Value:
if (ELPP_DEBUG_LOG) CVLOG_N_TIMES(n, vlevel, __VA_ARGS__)
CVLOG_N_TIMES
#define CVLOG_N_TIMES(n, vlevel,...)
Definition easylogging++.h:4311

◆ DPLOG

#define DPLOG ( LEVEL)
Value:
DCPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
ELPP_CURR_FILE_LOGGER_ID
#define ELPP_CURR_FILE_LOGGER_ID
Definition easylogging++.h:4331
DCPLOG
#define DCPLOG(LEVEL,...)
Definition easylogging++.h:4361

◆ DPLOG_IF

#define DPLOG_IF ( condition,
LEVEL )
Value:
DCPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
DCPLOG_IF
#define DCPLOG_IF(condition, LEVEL,...)
Definition easylogging++.h:4363

◆ DSYSLOG

#define DSYSLOG ( LEVEL)
Value:
el::base::NullWriter()

◆ DSYSLOG_AFTER_N

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

◆ DSYSLOG_EVERY_N

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

◆ DSYSLOG_IF

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

◆ DSYSLOG_N_TIMES

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

◆ el_getVALength

#define el_getVALength ( ...)
Value:
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,...)
Definition easylogging++.h:3457

◆ el_resolveVALength

#define el_resolveVALength ( _0,
_1,
_2,
_3,
_4,
_5,
_6,
_7,
_8,
_9,
_10,
N,
... )
Value:
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_INTERNAL_DEBUGGING_OUT_ERROR
#define ELPP_INTERNAL_DEBUGGING_OUT_ERROR
Definition easylogging++.h:160
ELPP_INTERNAL_DEBUGGING_ENDL
#define ELPP_INTERNAL_DEBUGGING_ENDL
Definition easylogging++.h:163
ELPP_INTERNAL_DEBUGGING_MSG
#define ELPP_INTERNAL_DEBUGGING_MSG(msg)
Definition easylogging++.h:166

◆ 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)
Value:
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   0

◆ ELPP_ERROR_LOG

#define ELPP_ERROR_LOG   0

◆ ELPP_EXPORT

#define ELPP_EXPORT

◆ ELPP_FATAL_LOG

#define ELPP_FATAL_LOG   0

◆ ELPP_FINAL

#define ELPP_FINAL

◆ ELPP_FUNC

#define ELPP_FUNC   ""

◆ ELPP_INFO_LOG

#define ELPP_INFO_LOG   0

◆ 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); \
}
el::base::debug::CrashHandler
Definition easylogging++.h:3686
ELPP_USE_DEF_CRASH_HANDLER
#define ELPP_USE_DEF_CRASH_HANDLER
Definition easylogging++.h:4608
base
Definition base.py:1
el::base::type::StoragePointer
base::Storage * StoragePointer
Definition easylogging++.h:560
el
Easylogging++ entry namespace.
Definition easylogging++.cc:27

◆ ELPP_INITIALIZE_SYSLOG

#define ELPP_INITIALIZE_SYSLOG ( id,
opt,
fac )
Value:
el::SysLogInitializer elSyslogInit(id, opt, fac)
el::SysLogInitializer
Initializes syslog with process ID, options and facility. calls closelog() on d'tor.
Definition easylogging++.h:3697

◆ ELPP_INTERNAL_DEBUGGING_ENDL

#define ELPP_INTERNAL_DEBUGGING_ENDL   std::endl

◆ ELPP_INTERNAL_DEBUGGING_MSG

#define ELPP_INTERNAL_DEBUGGING_MSG ( msg)
Value:
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()); \
}
operator<<
std::ostream & operator<<(std::ostream &os, const Student &s)
Definition archivertest.cpp:30

◆ 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)
Value:
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
#define ELPP
Definition easylogging++.h:2794

◆ 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   0

◆ ELPP_UNUSED

#define ELPP_UNUSED ( x)
Value:
(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   0

◆ ELPP_WARNING_LOG

#define ELPP_WARNING_LOG   0

◆ ELPP_WRITE_LOG

#define ELPP_WRITE_LOG ( writer,
level,
dispatchAction,
... )
Value:
writer(level, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
ELPP_FUNC
#define ELPP_FUNC
Definition easylogging++.h:312
el_getVALength
#define el_getVALength(...)
Definition easylogging++.h:3454
el::Color::Default
@ Default
Definition easylogging++.h:612

◆ 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)
Value:
CLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)

◆ LOG_AFTER_N

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

◆ LOG_EVERY_N

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

◆ LOG_IF

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

◆ LOG_N_TIMES

#define LOG_N_TIMES ( n,
LEVEL )
Value:
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;\
}
ELPP_LITERAL
#define ELPP_LITERAL(txt)
Definition easylogging++.h:539
el::base::consts::kMaxLogPerContainer
static const unsigned int kMaxLogPerContainer
Definition easylogging++.h:766
el::base::type::ostream_t
std::ostream ostream_t
Definition easylogging++.h:550
el::base::type::char_t
char char_t
Definition easylogging++.h:546
el::LoggingFlag::NewLineForContainer
@ NewLineForContainer
Makes sure we have new line for each container log entry.
Definition easylogging++.h:727

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

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

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

◆ MAKE_LOGGABLE

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

◆ PERFORMANCE_CHECKPOINT

#define PERFORMANCE_CHECKPOINT ( obj)
Value:
obj->checkpoint(std::string(), __FILE__, __LINE__, ELPP_FUNC)

◆ PERFORMANCE_CHECKPOINT_WITH_ID

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

◆ PLOG

#define PLOG ( LEVEL)
Value:
CPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
CPLOG
#define CPLOG(LEVEL,...)
Definition easylogging++.h:4357

◆ PLOG_IF

#define PLOG_IF ( condition,
LEVEL )
Value:
CPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
CPLOG_IF
#define CPLOG_IF(condition, LEVEL,...)
Definition easylogging++.h:4359

◆ 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 )
Value:
el::Helpers::setArgs(argc, argv)
el::Helpers::setArgs
static void setArgs(int argc, char **argv)
Sets application arguments and figures out whats active for logging and whats not.
Definition easylogging++.h:3727

◆ STRCAT

#define STRCAT ( a,
b,
len )
Value:
strcat(a, b)
b
cryptonote::block b
Definition block.cpp:40
a
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition pointer.h:1124

◆ STRCPY

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

◆ STRERROR

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

◆ STRTOK

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

◆ SYSLOG

#define SYSLOG ( LEVEL)
Value:
el::base::NullWriter()

◆ SYSLOG_AFTER_N

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

◆ SYSLOG_EVERY_N

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

◆ SYSLOG_IF

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

◆ SYSLOG_N_TIMES

#define SYSLOG_N_TIMES ( n,
LEVEL )
Value:
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)
ELPP_MIN_UNIT
#define ELPP_MIN_UNIT
Definition easylogging++.h:3990
el::base::type::PerformanceTrackerPtr
std::unique_ptr< el::base::PerformanceTracker > PerformanceTrackerPtr
Definition easylogging++.h:564

◆ TIMED_FUNC

#define TIMED_FUNC ( obj)
Value:
TIMED_SCOPE(obj, ELPP_FUNC)
TIMED_SCOPE
#define TIMED_SCOPE(obj, blockname)
Definition easylogging++.h:4001

◆ TIMED_FUNC_IF

#define TIMED_FUNC_IF ( obj,
condition )
Value:
TIMED_SCOPE_IF(obj, ELPP_FUNC, condition)
TIMED_SCOPE_IF
#define TIMED_SCOPE_IF(obj, blockname, condition)
Performance tracked scope. Performance gets written when goes out of scope using 'performance' logger...
Definition easylogging++.h:3999

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

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

See also
el::base::PerformanceTracker
el::base::PerformanceTracker::checkpoint

◆ TIMED_SCOPE

#define TIMED_SCOPE ( obj,
blockname )
Value:
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.

@detail 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)
Value:
CVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID)

◆ VLOG_AFTER_N

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

◆ VLOG_EVERY_N

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

◆ VLOG_IF

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

◆ VLOG_IS_ON

#define VLOG_IS_ON ( verboseLevel)
Value:
(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 )
Value:
CVLOG_N_TIMES(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
Generated on for Monero by doxygen 1.16.1