Description:

This class acts as a container for Loggers and provides a convenient interface to logging.

Definition at line 57 of file lox.inl.

Collaboration diagram for Lox:

Public Static Field Index:
static constexpr NString	InternalDomains { "$/" }

Public Static Method Index:
static ALIB_API textlogger::TextLogger *	CreateConsoleLogger (const NString &name=nullptr)

Public Method Index:
	Lox (const NString &name, bool doRegister=true)

	~Lox ()
	Destructs a lox.

void	Acquire (const lang::CallerInfo &ci)

template<typename... BoxedObjects>
void	Assert (bool condition, BoxedObjects &&... logables)

void	ClearSourcePathTrimRules (lang::Reach reach=lang::Reach::Global, bool allowAutoRule=true)

MonoAllocator &	DbgGetMonoAllocator ()

void	Entry (const NString &domain, Verbosity verbosity)

template<typename... BoxedObjects>
void	EntryDetectDomain (Verbosity verbosity, BoxedObjects &&... logables)

template<typename... BoxedObjects>
void	Error (BoxedObjects &&... logables)

BoxesMA &	GetLogableContainer ()

integer &	GetLogCounter ()

detail::Logger *	GetLogger (const NString &loggerName)

const NString &	GetName ()

void	GetState (NAString &buf, StateInfo flags=StateInfo::All)

template<typename... BoxedObjects>
void	If (bool condition, const NString &domain, Verbosity verbosity, BoxedObjects &&... logables)

template<typename... BoxedObjects>
void	If (bool condition, Verbosity verbosity, BoxedObjects &&... logables)

template<typename... BoxedObjects>
void	Info (BoxedObjects &&... logables)

int	IsActive (Verbosity verbosity, const NString &domain=NULL_NSTRING)

void	MapThreadName (const String &threadName, threads::ThreadID id=0)

void	Once (const Box &logables, const String &group, int quantity=1)

void	Once (const Box &logables, const String &group, Scope scope, int quantity=1)

void	Once (const Box &logables, int quantity=1)

void	Once (const Box &logables, Scope scope, int quantity=1)

void	Once (const NString &domain, Verbosity verbosity, const Box &logables, const String &group, Scope scope=Scope::Global, int quantity=1)

void	Once (const NString &domain, Verbosity verbosity, const Box &logables, Scope scope=Scope::Global, int quantity=1)

void	Once (Verbosity verbosity, const Box &logables, const String &group, int quantity=1)

void	Once (Verbosity verbosity, const Box &logables, const String &group, Scope scope, int quantity=1)

void	Once (Verbosity verbosity, const Box &logables, int quantity=1)

void	Once (Verbosity verbosity, const Box &logables, Scope scope, int quantity=1)

void	Release ()

detail::Logger *	RemoveLogger (const NString &loggerName)

bool	RemoveLogger (detail::Logger *logger)

void	RemoveThreadDomain (const NString &scopeDomain, Scope scope, threads::Thread *thread=nullptr)

void	Reset ()

ALIB_API Box	Retrieve (const NString &key, Scope scope=Scope::Global)

ALIB_API Box	Retrieve (Scope scope=Scope::Global)

void	SetDomain (const NString &scopeDomain, Scope scope)

void	SetDomain (const NString &scopeDomain, Scope scope, threads::Thread *thread)

void	SetDomainSubstitutionRule (const NString &domainPath, const NString &replacement)

void	SetFileNameCacheCapacity (integer numberOfLists, integer entriesPerList)

void	SetPrefix (const Box &prefix, const NString &domain=nullptr, lang::Inclusion otherPLs=lang::Inclusion::Include)

void	SetPrefix (const Box &prefix, Scope scope)

void	SetPrefix (const Box &prefix, Scope scope, threads::Thread *thread)

void	SetSourcePathTrimRule (const NCString &path, lang::Inclusion includeString=lang::Inclusion::Exclude, int trimOffset=0, lang::Case sensitivity=lang::Case::Ignore, const NString &trimReplacement=NULL_NSTRING, lang::Reach reach=lang::Reach::Global, Priority priority=Priority::Standard)

void	SetStartTime (const FILETIME &startTime, const NString &loggerName=nullptr)

void	SetStartTime (Ticks startTime=time::Ticks(), const NString &loggerName=nullptr)

void	SetStartTime (time_t startTime, const NString &loggerName=nullptr)

void	SetVerbosity (const NString &loggerName, Verbosity verbosity, const NString &domain="/", Priority priority=Priority::Standard)

void	SetVerbosity (detail::Logger *logger, Verbosity verbosity, const NString &domain="/", Priority priority=Priority::Standard)

void	State (const NString &domain, Verbosity verbosity, const String &headLine, StateInfo flags=StateInfo::All)

void	Store (const Box &data, const NString &key, Scope scope=Scope::Global)

void	Store (const Box &data, Scope scope=Scope::Global)

template<typename... BoxedObjects>
void	Verbose (BoxedObjects &&... logables)

template<typename... BoxedObjects>
void	Warning (BoxedObjects &&... logables)

Protected Field Index:
detail::LoxImpl *	impl
	The implementation.

Field Details:

◆ impl

detail::LoxImpl* impl

protected

The implementation.

Definition at line 66 of file lox.inl.

◆ InternalDomains

NString InternalDomains { "$/" }

staticconstexpr

This is the path for logging to the internal domain. By manipulating this Log Domain's Verbosity, the verbosity of ALox itself can be controlled. For example, with Verbosity.INFO, the 'on the fly' creation of Log Domains are logged, which can be helpful to determine the Lo bg Domains that are created by libraries and larger projects.

The following Subdomains are used by ALox:

Subdomain	Description
LGR	Used when Loggers are registered, retrieved or removed from a Lox and when the Verbosity of a Log Domain for a Logger is changed. In addition used with method Lox::SetStartTime.
DMN	Used when Log Domains are registered (on first use), when Scope Domains are set or removed and when Domain Substitution Rules are set.
PFX	Used when Prefix Logables are set or removed.
THR	Used with method Lox::MapThreadName.
LGD	Used with storing and retrieving Log Data objects.

In addition, class ALoxReportWriter logs into subdomain 'REPORT'.

Note: For internal logging an separated domain tree is used. This means, that setting the root domain of a Lox to a certain Verbosity does not affect the internal domains. In other words, the Verbosity of the internal domain (or one of its Subdomains) has to be set explicitly.

Definition at line 92 of file lox.inl.

Constructor(s) / Destructor Details:

◆ Lox()

Lox	(	const NString &	name,
		bool	doRegister = true )

inline

Constructs a new, empty Lox with the given name. The name is immutable and all Lox objects registered with ALox must be unique. Lower case letters in the name are converted to upper case. The name "Log" is reserved for the internal default singleton used for debug-logging. In addition, name "GLOBAL" is not allowed.

If parameter register is true (the default), static method alib::lox,ALoxCamp::Register "lox,ALoxCamp::Register" is invoked and the object will be retrievable with static method alib::lox,ALoxCamp::Get "lox,ALoxCamp::Get". In some situations, such 'registration' may not be wanted.

Parameters

name	The name of the Lox. Will be copied and converted to upper case.
doRegister	If `true`, this object is registered with static class alib::lox,ALoxCamp "lox,ALoxCamp". Optional and defaults to `true`.

Definition at line 115 of file lox.inl.

Here is the call graph for this function:

◆ ~Lox()

~Lox ( )

inline

Destructs a lox.

Definition at line 123 of file lox.inl.

Here is the call graph for this function:

Method Details:

◆ Acquire()

void Acquire ( const lang::CallerInfo & ci )

inline

Acquires this Lox and sets the scope information data for the next log.

Parameters

ci	The source location that the call is placed at.

Definition at line 161 of file lox.inl.

Here is the call graph for this function:

◆ Assert()

template<typename... BoxedObjects>

void Assert	(	bool	condition,
		BoxedObjects &&...	logables )

inline

Logs given logables only if the parameter condition is not true. If executed, Verbosity::Error is used.

The first object provided may be a domain name. All values are passed to EntryDetectDomain. See documentation of this method for information on how to avoid ambiguities in respect to domain names.

If one of the arguments (or a single argument given) is of type alib::boxing,TBoxes "boxing,TBoxes", then the contents of this list are inserted into the list of logables. This allows collecting logables before invoking the method.

Parameters

condition	If `false`, the Log Statement is executed.
logables	The list of Logables, optionally including a domain name at the start.

Definition at line 1094 of file lox.inl.

Here is the call graph for this function:

◆ ClearSourcePathTrimRules()

void ClearSourcePathTrimRules	(	lang::Reach	reach = lang::Reach::Global,
		bool	allowAutoRule = true )

inline

Removes all local trimming rules set with SetSourcePathTrimRule. If parameter global is set to Inclusion::Include, the global rules are cleared in addition.

Setting parameter allowAutoRule to false, allows suppressing the creation of an automatic rule based on the executables path.

See also: Chapter 14 Trimming Source File Paths and Clickable IDE Output for more information.

Parameters

reach	Denotes whether only local rules are cleared or also global ones. Defaults to Reach::Global.
allowAutoRule	Determines if an auto rule should be tried to be detected next no appropriate rule is found.

Definition at line 277 of file lox.inl.

Here is the call graph for this function:

◆ CreateConsoleLogger()

TextLogger * CreateConsoleLogger ( const NString & name = nullptr )

static

This static method creates a console logger. To decide which logger type to choose, configuration variable ALOX/CONSOLE_TYPE is checked. If this variable is not set, then the decision is made as follows:

On GNU/Linux OS, a AnsiConsoleLogger is chosen.
On Windows OS, if a console window is attached, type WindowsConsoleLogger is chosen. If no console is attached to the process, instead a ConsoleLogger is returned.

Parameters

name	The name of the Logger. Defaults to nullptr, which uses standard names defined by derived Logger types.

Returns: An instance of the chosen console type logger.

Definition at line 2416 of file loxpimpl.cpp.

Here is the call graph for this function:

◆ DbgGetMonoAllocator()

MonoAllocator & DbgGetMonoAllocator ( )

inline

Returns the internal MonoAllocator used for storing permanent data.

Availability: This method is available only with debug-builds with ALIB_DEBUG_MONOMEM set.

Returns: The monotonic allocator of this Lox.

Definition at line 1438 of file lox.inl.

Here is the call graph for this function:

◆ Entry()

void Entry	(	const NString &	domain,
		Verbosity	verbosity )

inline

Logs the current list of Logables that previously have been received using GetLogableContainer with the given verbosity.

This method is usually not used directly. Instead, methods Info, Verbose, Warning and Error provide simpler interfaces which take variadic arguments that are collected in a list of boxed objects and then passed to this methods.
Note that the other interface methods accept an "external" list of boxes as a parameter. as well. This means also with these methods it is allowed to collect the logables in an user-specific list first and later pass them to these methods.

Hence, the use of this method is recommended only if the verbosity of a log statement is evaluated only at run-time.

Parameters

domain	The domain.
verbosity	The verbosity.

Definition at line 960 of file lox.inl.

Here is the call graph for this function:

◆ EntryDetectDomain()

template<typename... BoxedObjects>

void EntryDetectDomain	(	Verbosity	verbosity,
		BoxedObjects &&...	logables )

inline

Logs a list of Logables with the given Verbosity.

If more than one Logable is given and the first one is of string-type and comprises a valid domain path, then this first argument is interpreted as the domain name! Valid domain path are strings that consists only of characters of the following set:

upper case letters,
numbers,
hyphen ('-'),
underscore ('_') and
forward slash ('/').

If a first Logable could be misinterpreted as being a domain name, an empty string (the "neutral" domain) has to be added as a first argument. Alternatively, a character which is illegal in respect to domain names could be added to the first argument, for example a simple space at the end of an output string.

Note: This method allows a consistent interface of overloaded methods Info, Error, etc, without introducing a separate version which excepts a - then mandatory - domain parameter. The little drawback of the auto detection is the possibility of ambiguous invocations.

Parameters

verbosity	The verbosity.
logables	The list of Logables, optionally including a domain name at the start.

Definition at line 992 of file lox.inl.

Here is the call graph for this function:

◆ Error()

template<typename... BoxedObjects>

void Error ( BoxedObjects &&... logables )

inline

Logs given logables using Verbosity::Error.

The first object provided may be a domain name. All values are passed to EntryDetectDomain. See documentation of this method for information on how to avoid ambiguities in respect to domain names.

If one of the arguments (or a single argument given) is of type alib::boxing,TBoxes "boxing,TBoxes", then the contents of this list is inserted into the list of logables. This allows collecting logables before invoking the method.

Parameters

logables The list of Logables, optionally including a domain name at the start.

Definition at line 1072 of file lox.inl.

Here is the call graph for this function:

◆ GetLogableContainer()

BoxesMA & GetLogableContainer ( )

inline

Returns a reference to a list of boxes to be used for logging. The list is recycled from a previous log operation and cleared. The method may be used to retrieve a container for logables that then are collected until finally logged.
Note that the Lox instance has to be acquired before invoking this method and the container returned must be used only while the object is still acquired.

With each recursive acquirement of this object, a different container is returned. This is implemented to allow recursive log calls.

Returns: An empty list of boxes.

Definition at line 937 of file lox.inl.

Here is the call graph for this function:

◆ GetLogCounter()

integer & GetLogCounter ( )

inline

Returns the number of logs that have been performed with this Lox. The counter is not used internally other than for providing a unique log number: While each logger attached has a own number, if more than one logger is attached, their numbers may differ due to different log domain settings.

Note: The result is given as a mutual reference to the internal counter, which is allowed to be manipulated. This is for example used in unit tests.

Returns: true if this instance was registered with ALox, false if not.

Definition at line 154 of file lox.inl.

Here is the call graph for this function:

◆ GetLogger()

detail::Logger * GetLogger ( const NString & loggerName )

inline

Retrieves an instance of a Logger by its name. This might be useful when access to a Logger is needed to change its configuration.

Parameters

loggerName The name of the Logger to search for (case insensitive).

Returns: The logger, nullptr if not found.

Definition at line 313 of file lox.inl.

Here is the call graph for this function:

◆ GetName()

const NString & GetName ( )

inline

Returns the name of this Lox. The name is user-defined, and provided in the constructor, converted to upper case and otherwise immutable.

Returns: The name of this Lox.

Definition at line 138 of file lox.inl.

Here is the call graph for this function:

◆ GetState()

void GetState	(	NAString &	buf,
		StateInfo	flags = StateInfo::All )

inline

This method collects state information about this lox in a formatted multi-line AString. Parameter flags is a bitwise enum type (operators on elements available).

Note: As an alternative to (temporarily) adding an invocation of Lox.State to your code, ALox provides configuration variable ALOX/LOXNAME/DUMP_STATE_ON_EXIT. This allows enabling an automatic invocation of this method using external configuration data like command line parameters, environment variables or INI files.

Parameters

buf	The target string.
flags	Bits that define which state information is collected.

Definition at line 916 of file lox.inl.

Here is the call graph for this function:

◆ If() [1/2]

template<typename... BoxedObjects>

void If	(	bool	condition,
		const NString &	domain,
		Verbosity	verbosity,
		BoxedObjects &&...	logables )

inline

Logs a list of Logables only if the parameter condition is true.

See also: Method Assert.

Parameters

condition	If `false`, the Log Statement is executed.
domain	Optional Log Domain which is combined with Scope Domains set for the Scope of invocation.
verbosity	The verbosity.
logables	The list of Logables.

Definition at line 1117 of file lox.inl.

Here is the call graph for this function:

◆ If() [2/2]

template<typename... BoxedObjects>

void If	(	bool	condition,
		Verbosity	verbosity,
		BoxedObjects &&...	logables )

inline

Logs a list of Logables only if the parameter condition is true.

This overloaded version omits parameter domain. The first logable provided may be a domain name. All values are passed to EntryDetectDomain. See documentation of this method for information on how to avoid ambiguities in respect to domain names.

If one of the arguments (or a single argument given) is of type alib::boxing,TBoxes "boxing,TBoxes", then the contents of this list is inserted into the list of logables. This allows collecting logables before invoking the method.

See also: Method Assert.

Parameters

condition	If `false`, the Log Statement is executed.
verbosity	The verbosity.
logables	The list of Logables.

Definition at line 1147 of file lox.inl.

Here is the call graph for this function:

◆ Info()

template<typename... BoxedObjects>

void Info ( BoxedObjects &&... logables )

inline

Logs given logables using Verbosity::Info.

The first object provided may be a domain name. All values are passed to EntryDetectDomain. See documentation of this method for information on how to avoid ambiguities in respect to domain names.

If one of the arguments (or a single argument given) is of type alib::boxing,TBoxes "boxing,TBoxes", then the contents of this list is inserted into the list of logables. This allows collecting logables before invoking the method.

Parameters

logables The list of Logables, optionally including a domain name at the start.

Definition at line 1032 of file lox.inl.

Here is the call graph for this function:

◆ IsActive()

int IsActive	(	Verbosity	verbosity,
		const NString &	domain = NULL_NSTRING )

inline

Returns the number of loggers attached, which are active in respect to the given combination of verbosity and log domain.

This method may be used to avoid the execution of more complex logging code when such logging would not result in log activity due to the current log level settings.

Parameters

verbosity	The verbosity to query for activity.
domain	The log domain. All rules for resolving the effective log domain apply as with normal log statements. Defaults to NullNString.

Returns: The number of active loggers.

Definition at line 1421 of file lox.inl.

Here is the call graph for this function:

◆ MapThreadName()

void MapThreadName	(	const String &	threadName,
		threads::ThreadID	id = 0 )

inline

This method sets a human-readable name to the given thread ID (or current thread) which is optionally included in each log line.

Parameters

threadName	The name of the thread as it should be displayed in the logs.
id	(Optional) Parameter providing the thread ID. If omitted, the current thread's ID is used. If given, the associated object of Thread must not be deleted until this method returns. This is a race condition that a using code has do ensure.

Definition at line 787 of file lox.inl.

Here is the call graph for this function:

◆ Once() [1/10]

void Once	(	const Box &	logables,
		const String &	group,
		int	quantity = 1 )

inline

Overloaded version of Once.

Parameters

logables	The objects to log (Multiple objects may be provided within container class Boxes.)
group	The optional name of the statement group . If used, all statements that share the same group name are working on the same counter (according to the scope.) If omitted (or empty or nullptr), the counter is bound to the Scope provided. If omitted and scope is Scope::Global, then the counter is associated exclusively with the single Log Statement itself.
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`.

Definition at line 1402 of file lox.inl.

Here is the call graph for this function:

◆ Once() [2/10]

void Once	(	const Box &	logables,
		const String &	group,
		Scope	scope,
		int	quantity = 1 )

inline

Overloaded version of Once.

Parameters

logables	The objects to log (Multiple objects may be provided within container class Boxes.)
group	The optional name of the statement group . If used, all statements that share the same group name are working on the same counter (according to the scope.) If omitted (or empty or nullptr), the counter is bound to the Scope provided. If omitted and scope is Scope::Global, then the counter is associated exclusively with the single Log Statement itself.
scope	The Scope that the group or counter is bound to.
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`.

Definition at line 1309 of file lox.inl.

Here is the call graph for this function:

◆ Once() [3/10]

void Once	(	const Box &	logables,
		int	quantity = 1 )

inline

Overloaded version of Once.

Parameters

logables	The objects to log (Multiple objects may be provided within container class Boxes.)
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`.

Definition at line 1381 of file lox.inl.

Here is the call graph for this function:

◆ Once() [4/10]

void Once	(	const Box &	logables,
		Scope	scope,
		int	quantity = 1 )

inline

Overloaded version of Once.

Parameters

logables	The objects to log (Multiple objects may be provided within container class Boxes.)
scope	The Scope that the group or counter is bound to.
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`.

Definition at line 1365 of file lox.inl.

Here is the call graph for this function:

◆ Once() [5/10]

void Once	(	const NString &	domain,
		Verbosity	verbosity,
		const Box &	logables,
		const String &	group,
		Scope	scope = Scope::Global,
		int	quantity = 1 )

inline

Logs given logables once, up to quantity times, or every n-th time. In its simplest overloaded version, the counter is bound to the source code line, hence, only the first execution of this exact Log Statement is executed.

With parameter group, a set of Log Statements that share the same group key, can be grouped and of such set, only the one which is first executed actually logs.
Alternatively, when key is omitted (or nullptr or empty), but a Scope is given with parameter scope, then the counter is associated with the scope.
Finally, parameters key and scope can also be used in combination. The key is then unique in respect to the Scope provided.

Using, none, one or both of the parameters group and scope, among others, the following use cases can be achieved.

Log a specific statement up to n-times.
Log only the first n of a group of statements.
Log only the first n statements within a method.
Log only the first n statements belonging to the same group and method .
Log only the first n statements within any method of
- a source file
- a directory of source files
- a parent directory of source files and all sources recursively
Log only the first n statements which belong to the same group and are placed within any method of
- a source file
- a directory of source files
- a parent directory of source files and all sources recursively
Log a Log Statement n-times per new thread.
Log only the first n statements of a group of statements executed by a specific thread.

When parameter quantity is a negative value, the log statement is executed every n-th time instead n-times. E.g, if quantity is -5, the first statement is executed and afterwards every fifth invocation.

Note: Unlike other methods of this class which accept an arbitrary amount of logables, this method and its overloaded variants accept only one boxed object. To still be able to supply several objects at once, an array of boxes or a container of type alib::boxing,TBoxes "boxing,TBoxes" may be passed with parameter logables, like in the following sample:
// passing an array

{

Log_Prune( Box logables[3]= { "One - {} - {}!", "two", 3 }; )

Log_Once( logables )

}

// passing a vector of boxes (less efficient than above, if the container object is used only once)

{

Log_Prune( BoxesHA logables; )

Log_Prune( logables.Add("One - {} - {}!", "two", 3 ) );

Log_Once( logables )

}

This is why the parameter name logables still uses the plural with its name!

Parameters

domain	Optional Log Domain which is combined with Scope Domains set for the Scope of invocation.
verbosity	The verbosity of the Log Statement (if performed).
logables	The objects to log (Multiple objects may be provided within container class Boxes.)
group	The optional name of the statement group . If used, all statements that share the same group name are working on the same counter (according to the scope.) If omitted (or empty or nullptr), the counter is bound to the Scope provided. If omitted and scope is Scope::Global, then the counter is associated exclusively with the single Log Statement itself.
scope	The Scope that the group or counter is bound to.
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`. If negative, the first and every "-quantity-th" statement is executed.

Definition at line 1220 of file lox.inl.

Here is the call graph for this function:

◆ Once() [6/10]

void Once	(	const NString &	domain,
		Verbosity	verbosity,
		const Box &	logables,
		Scope	scope = Scope::Global,
		int	quantity = 1 )

inline

Overloaded version of Once.

Parameters

domain	Optional Log Domain which is combined with Scope Domains set for the Scope of invocation.
verbosity	The verbosity of the Log Statement (if performed).
logables	The objects to log (Multiple objects may be provided within container class Boxes.)
scope	The Scope that the group or counter is bound to.
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`.

Definition at line 1330 of file lox.inl.

Here is the call graph for this function:

◆ Once() [7/10]

void Once	(	Verbosity	verbosity,
		const Box &	logables,
		const String &	group,
		int	quantity = 1 )

inline

Overloaded version of Once.

Parameters

verbosity	The verbosity of the Log Statement (if performed).
logables	The objects to log (Multiple objects may be provided within container class Boxes.)
group	The optional name of the statement group . If used, all statements that share the same group name are working on the same counter (according to the scope.) If omitted (or empty or nullptr), the counter is bound to the Scope provided. If omitted and scope is Scope::Global, then the counter is associated exclusively with the single Log Statement itself.
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`.

Definition at line 1270 of file lox.inl.

Here is the call graph for this function:

◆ Once() [8/10]

void Once	(	Verbosity	verbosity,
		const Box &	logables,
		const String &	group,
		Scope	scope,
		int	quantity = 1 )

inline

Overloaded version of Once.

Parameters

verbosity	The verbosity of the Log Statement (if performed).
logables	The objects to log (Multiple objects may be provided within container class Boxes.)
group	The optional name of the statement group . If used, all statements that share the same group name are working on the same counter (according to the scope.) If omitted (or empty or nullptr), the counter is bound to the Scope provided. If omitted and scope is Scope::Global, then the counter is associated exclusively with the single Log Statement itself.
scope	The Scope that the group or counter is bound to.
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`.

Definition at line 1246 of file lox.inl.

Here is the call graph for this function:

◆ Once() [9/10]

void Once	(	Verbosity	verbosity,
		const Box &	logables,
		int	quantity = 1 )

inline

Overloaded version of Once.

Parameters

verbosity	The verbosity of the Log Statement (if performed).
logables	The objects to log (Multiple objects may be provided within container class Boxes.)
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`.

Definition at line 1287 of file lox.inl.

Here is the call graph for this function:

◆ Once() [10/10]

void Once	(	Verbosity	verbosity,
		const Box &	logables,
		Scope	scope,
		int	quantity = 1 )

inline

Overloaded version of Once.

Parameters

verbosity	The verbosity of the Log Statement (if performed).
logables	The objects to log (Multiple objects may be provided within container class Boxes.)
scope	The Scope that the group or counter is bound to.
quantity	The number of logs to be performed. As the name of the method indicates, this defaults to `1`.

Definition at line 1348 of file lox.inl.

Here is the call graph for this function:

◆ Release()

void Release ( )

inline

Releases ownership of this object. If Acquire was called multiple times, the same number of calls to this method have to be performed to release ownership.

Definition at line 167 of file lox.inl.

Here is the call graph for this function:

◆ RemoveLogger() [1/2]

detail::Logger * RemoveLogger ( const NString & loggerName )

inline

Removes logger named loggerName from this container.

Note: To (temporarily) disable a logger without removing it, a call to SetVerbosity(logger, Verbosity::Off) can be used.

Parameters

loggerName The name of the Logger(s) to be removed (case insensitive).

Returns: The logger that was removed, nullptr if not found.

Definition at line 343 of file lox.inl.

Here is the call graph for this function:

◆ RemoveLogger() [2/2]

bool RemoveLogger ( detail::Logger * logger )

inline

Removes a logger from this container.

Note: To (temporarily) disable a logger without removing it, a call to SetVerbosity(logger, Verbosity::Off) can be used.

Parameters

logger The logger to be removed.

Returns: true, if the Logger was found and removed, false otherwise.

Definition at line 328 of file lox.inl.

Here is the call graph for this function:

◆ RemoveThreadDomain()

void RemoveThreadDomain	(	const NString &	scopeDomain,
		Scope	scope,
		threads::Thread *	thread = nullptr )

inline

This method is used to remove an explicitly given domain path from the list of domain paths set for Scope::ThreadOuter or Scope::ThreadInner.

To remove the most recently added domain path from such thread-related Scope, use one of the overloaded methods SetDomain and provide an empty or nulled value for parameter scopeDomain (the same as how domain paths of other Scopes are removed).

Note: The long name of the method already indicates that this method is a little special. Only seldom, more than one Scope Domain is needed to be added. And if this is needed, then such Scope Domains usually get removed in reverse order of their definition, with is performed using the standard interface that allows 'removing' any other Scope Domain. (Passing an empty or nulled domain path to method SetDomain.)

Parameters

scopeDomain	The domain path to register.
scope	Either Scope::ThreadOuter or Scope::ThreadInner. With other values, an internal error is logged.
thread	The thread to set/unset a thread-related Scope Domains for. Defaults to the current thread.

Definition at line 581 of file lox.inl.

Here is the call graph for this function:

◆ Reset()

void Reset ( )

inline

Resets this object.

Attention: This method was introduced to support resetting the debug Lox objects in the unit tests. In real applications, and for release logging it recommended to delete a Lox and create a new one instead of resetting one. Side effects might appear when using this method!

Definition at line 178 of file lox.inl.

Here is the call graph for this function:

◆ Retrieve() [1/2]

ALIB_API Box Retrieve	(	const NString &	key,
		Scope	scope = Scope::Global )

inline

Retrieves ALox Log Data, an object type Box which had been stored in a prior call to Store. Using the optional key and scope offer various possibilities to reference such objects.

Note: If no data is found, an nulled object is returned. This can be tested using method Box::IsNull.

Note: Log Data is a feature provided by ALox to support debug-logging. It is not advised to use Log Data to implement application logic.

Parameters

key	The optional key to the data. If omitted (or empty or nullptr), the data is bound to the Scope provided. If omitted and scope is Scope::Global, then the data is unique to the Lox.
scope	The Scope that the data is bound to.

Returns: The data, a nulled box if no value was found.

Definition at line 858 of file lox.inl.

Here is the call graph for this function:

◆ Retrieve() [2/2]

ALIB_API Box Retrieve ( Scope scope = Scope::Global )

inline

Overloaded version of Retrieve which omits parameter key.

Note: Log Data is a feature provided by ALox to support debug-logging. It is not advised to use Log Data to implement application logic.

Parameters

scope The Scope that the data is bound to.

Returns: The data, a nulled box if no value was found.

Definition at line 873 of file lox.inl.

Here is the call graph for this function:

◆ SetDomain() [1/2]

void SetDomain	(	const NString &	scopeDomain,
		Scope	scope )

inline

The given scopeDomain becomes the default domain path for given scope. This means, that any subsequent log invocations (from within this same scope) can omit the domain parameter, or if they provide one, this Scope Domain path is prepended. If subsequent log calls specify a domain name with a leading '/' character, then the Scope Domain of the scope is ignored.
Furthermore, if the given scope is an inner scope, outer scopes are prepended to the given scopeDomain when the resulting domain of a log invocation is evaluated. Again, this behavior can be overruled by prepending a leading '/' character to scopeDomain.

To remove a previously set Scope Domain a nulled or empty string has to be passed with parameter scopeDomain. For Scope::ThreadOuter and Scope::ThreadInner, passing an empty or nulled string removes the most recently added domain path. For removing an explicitly named domain path of Scope::ThreadOuter and Scope::ThreadInner use method RemoveThreadDomain.

Note: The C++ version of ALox implements scope mechanisms using scope information generated by the preprocessor. By default, debug logging supports such caller information, release logging does not. This can be changed.
For more information on how to change such defaults, see documentation of preprocessor symbols ALOX_DBG_LOG_CI and ALOX_REL_LOG_CI.

Parameters

scopeDomain	The domain path to register.
scope	The scope that should the given domain be registered for. Available Scope definitions are platform/language dependent.

Definition at line 469 of file lox.inl.

Here is the call graph for this function:

◆ SetDomain() [2/2]

void SetDomain	(	const NString &	scopeDomain,
		Scope	scope,
		threads::Thread *	thread )

inline

This overloaded version of SetDomain is applicable only for Scope::ThreadOuter and Scope::ThreadInner and allows specifying the thread that the setting should be associated with.

If scopeDomain is nullptr or empty, the most recently added domain path is removed. For removing an explicitly named domain associated with a thread use method RemoveThreadDomain.

Parameters

scopeDomain	The domain path to register.
scope	Either Scope::ThreadOuter or Scope::ThreadInner. With other values, an internal error is logged.
thread	The thread to set/unset a thread-related Scope Domains for.

Definition at line 489 of file lox.inl.

Here is the call graph for this function:

◆ SetDomainSubstitutionRule()

void SetDomainSubstitutionRule	(	const NString &	domainPath,
		const NString &	replacement )

inline

Adds a Domain Substitution Rule. Domain Substitution is performed as a last step when evaluating the domain path of a Log Statement, taking Scope Domains and the optional parameter domain of the statement into account.

Wildcards
Parameter domainPath supports 'wildcard' character '*' at its beginning and at its end (or both). This allows having four types of rules:

Exact match
Prefix match (* at the end of domainPath)
Suffix match (* at the start of domainPath)
Substring match (* at both, start and the end of domainPath)

Only minimal checks are performed, e.g., if an exact match is requested, but domainPath does not start with character '/'. In this and some other cases, the rule is not stored and an internal warning is logged. Further checks, for example, for illegal domain path characters, are not performed. (Illegal domain path characters will be eliminated when the resulting domain path is to be created internally).

Circular Dependencies
If the given rules have circular dependencies, only a limited number (ten) replacements are performed. If this number of replacements for one Log Statement is exceeded, an internal warning message is logged. This is done only once over the life-time of a Logger.

Application of Rules
Rules are applied in the order of their definition. After all rules have been applied, this is repeated as long as at least one rule matches (up to ten times).

Deletion of Rules To delete a rule, invoke the method with the same parameter domainPath but with a 'nulled' or empty string for parameter replacement. To delete all rules, invoke the method with parameter domainPath 'nulled' or empty.

Final remarks Domain substitution is useful to permanently change ('redirect') domain paths of 3rd party code (e.g., libraries using ALox) or log statements that must not be changed for other reasons. It is advised to not 'overuse' this feature, as side effects are inherent to the concept of Domain Substitution. For example, an unwanted side effect might be that Prefix Logables are not applicable to the substituted domain, while other Prefix Logables are bound to the resulting domain.

For Lox objects that should be protected of external manipulation, it is advisable to remove all Domain Substitution Rules right after the Lox was created by invoking this method with a nulled value for parameter domainPath. The reason is that otherwise, through configuration files or command line parameters, domains of the Lox can be substituted and then the resulting domains Verbosities be overwritten using further configuration variables. Any prioritized 'internal' setting of Verbosities this way could be circumvented!

For more information consult the chapter 15 Log Domain Substitution of the Programmer's Manual.

Parameters

domainPath	The path to search. Has to start with either `'/'` or `'*'`.
replacement	The replacement path.

Definition at line 553 of file lox.inl.

Here is the call graph for this function:

◆ SetFileNameCacheCapacity()

void SetFileNameCacheCapacity	(	integer	numberOfLists,
		integer	entriesPerList )

inline

Changes the capacity of the LRUCacheTable for parsed file names by calling LRUCacheTable::Reserve.

Parameters

numberOfLists	The number of LRU-lists to use.
entriesPerList	The maximum length of each cache list.

Definition at line 187 of file lox.inl.

Here is the call graph for this function:

◆ SetPrefix() [1/3]

void SetPrefix	(	const Box &	prefix,
		const NString &	domain = nullptr,
		lang::Inclusion	otherPLs = lang::Inclusion::Include )

inline

The given prefix becomes a Prefix Logable associated to the given Log Domain. Prefix Logables associated with the Log Domain are added to the list of Logables right before the main Logable of the Log Statement itself. Multiple Prefix Logables can be added per Log Domain.

To remove the most recently added Prefix Logable associated with a Log Domain, nullptr has to be passed with parameter prefix.

Note: String-type Logables are duplicated internally by ALox when setting as Prefix Logables. This means, different to Prefix Logables of type AString or custom types, the life-cycle of the object passed in parameter prefix is allowed to end right after the invocation of this method. For more information consult manual chapter 7.5 Lifecycle Management of Prefix Logables in ALox for C++ as well as chapter 7.9 Bypass Custom Boxing With Identity-Boxing of the Programmer's Manual of module ALib Boxing.

Attention: The same as with most interface methods of this class, the given domain parameter is combined with Scope Domains set for the caller's Scope. To suppress this, an absolute domain path can be used. (Still any Scope Domain of Scope::Thread::Inner will be applied). The default value of parameter domain is "" which addresses the domain evaluated for the current scope.

Parameters

prefix	The Prefix Logable to set.
domain	The domain path. Defaults to `nullptr`, resulting in evaluated Scope Domain path.
otherPLs	If set to `Inclusion::Exclude`, scope-related Prefix Logables are ignored and only domain-related Prefix Logables are passed to the Loggers. Defaults to `Inclusion::Include`.

Definition at line 710 of file lox.inl.

Here is the call graph for this function:

◆ SetPrefix() [2/3]

void SetPrefix	(	const Box &	prefix,
		Scope	scope )

inline

The given prefix becomes a Prefix Logable provided to loggers with each log statement executed within the given scope. The list of objects received by a logger is sorted from outer scope to inner scope. The logable of the Log Statement itself, is the last in the list, except one or more Prefix Logables of Scope::ThreadInner are set. Those are (similar to how this Scope is used with Scope Domains) appended to the end of the list.

To remove a previously set Prefix Logable, nullptr has to be passed with parameter prefix. For Scope::ThreadOuter and Scope::ThreadInner, passing nullptr (respectively with the overloaded method accepting string messages, a nulled string) removes the most recently added Prefix Logable.

Note: Logables of boxed character array types are duplicated internally by ALox when setting as Prefix Logables. This means, in contrast to other types, for string-type Prefix Logables the life-cycle of the object passed in parameter prefix is allowed to end right after the invocation of this method. This is a convenience feature of ALox. However, this also means, that changes of the strings that occur after the string objects got set as a Prefix Logable, are not reflected.
To implement a "variable" Prefix Logable of string-type, an object of type AString might be passed wrapped in class std::reference_wrapper<AString>.
For more information consult manual chapter 7.5 Lifecycle Management of Prefix Logables in ALox for C++ as well as chapter 7.9 Bypass Custom Boxing With Identity-Boxing of the Programmer's Manual of module ALib Boxing. p>; Unlike other methods of this class which accept an arbitrary amount of logables, this method and its overloaded variants accept only one logable (the prefix). To supply several objects to be prefix logables at once, a container of type TBoxes may be passed with parameter logables, like in the following sample:
MonoAllocator ma(ALIB_DBG("UTAloxLS",) 1);

BoxesMA prefixes(ma);

prefixes.Add("One, ", "two, ", 3 );

Log_SetPrefix( prefixes, Scope::Global )

The provided container as well as the prefixes themselves have to be kept in memory until they are unset.

p>

Note: The C++ version of ALox implements scope mechanisms using scope information generated by the preprocessor. By default, debug logging supports such caller information, release logging does not. Both defaults can be changed with preprocessor symbols ALOX_DBG_LOG_CI and ALOX_REL_LOG_CI.

p>

Note: The word 'prefix' in this method's name and in the name of ALox feature Prefix Logables is chosen for the fact that with text loggers (which is the most widely applied use case for ALox) such objects are prefixes to the log message. Of course, with using Scope::ThreadInner, this turns into a suffix!
When using ALox to process arbitrary objects instead of text messages, the concept of Prefix Logables is still very useful. Just the name does not fit so well anymore. Think of 'SetContext' and Context Objects instead.

Parameters

prefix	The Prefix Logable to set.
scope	The scope that should the given domain be registered for. Available Scope definitions are platform/language dependent.

Definition at line 649 of file lox.inl.

Here is the call graph for this function:

◆ SetPrefix() [3/3]

void SetPrefix	(	const Box &	prefix,
		Scope	scope,
		threads::Thread *	thread )

inline

This overloaded version of SetPrefix is applicable only for Scope::ThreadOuter and Scope::ThreadInner and allows specifying the thread that the setting should be associated with.

If scopeDomain is nullptr or empty, the most recently added Prefix Logable is removed.

Parameters

prefix	The Prefix Logable to set.
scope	Either Scope::ThreadOuter or Scope::ThreadInner. With other values, an internal error is logged.
thread	The thread to set/unset a thread-related Scope Domains for.

Definition at line 668 of file lox.inl.

Here is the call graph for this function:

◆ SetSourcePathTrimRule()

void SetSourcePathTrimRule	(	const NCString &	path,
		lang::Inclusion	includeString = lang::Inclusion::Exclude,
		int	trimOffset = 0,
		lang::Case	sensitivity = lang::Case::Ignore,
		const NString &	trimReplacement = NULL_NSTRING,
		lang::Reach	reach = lang::Reach::Global,
		Priority	priority = Priority::Standard )

inline

Adds path to an internal list of substrings that are used to trim the path of a source file name. Trimmed paths are used for Scope mechanisms and can be logged (e.g., with meta-information of class TextLogger.

By default such setting affects all instances of class Lox, not only this instance. This can be altered using parameter global. one other The given trim information can either

If given path starts with character '*', the rest of the string is searched within source paths. Otherwise, it is checked if a source path starts with the given path.

Parameter trimReplacement optionally provides a replacement string for the trimmed path. This can be used for example to provide the right absolute path for an IDE to find source files of a library.

Parameter includeString determines if the searched substring should be included in the resulting source path or not. In addition, parameter trimOffset, which can be negative or positive, is added to the position of trimming. This can be used to increase the length of the search path, and then cut only a portion of what was searched for.

Finally, parameter sensitivity determines whether the match is performed case sensitive or not. It defaults to non-sensitive, for convenience and for the fact that for example Microsoft C++ compiler's preprocessor passes lower case path-strings!

Note: If the platform (compiler) specific path separator is '/', then characters '\' found in parameters path and trimReplacement are replaced by '\' and vice versa. This allows specifying paths and substrings thereof in a platform independent way.

Attention: Setting global rules (when parameter global equals Inclusion::Include) is not protected by a mutex against concurrent access. Therefore, global rules have to be either at bootstrap of a process, before threads are created, or such creation has to 'manually' be protected by locking all existing instances of this class!

Parameters

path	The path to search for. If not starting with `'*'`, a prefix is searched.
includeString	Determines if path should be included in the trimmed path or not. Optional and defaults to Inclusion::Exclude.
trimOffset	Adjusts the portion of path that is trimmed. Optional and defaults to `0`.
sensitivity	Determines if the comparison of path with a source file's path is performed case-sensitive or not. Optional and defaults to Case::Ignore.
trimReplacement	Replacement string for trimmed portion of the path. Optional and defaults to NULL_STRING.
reach	Denotes whether the rule is applied locally (to this Lox only) or applies to all instances of class Lox. Defaults to Reach::Global.
priority	The priority of the setting. Defaults to Standard.

Definition at line 248 of file lox.inl.

Here is the call graph for this function:

◆ SetStartTime() [1/3]

void SetStartTime	(	const FILETIME &	startTime,
		const NString &	loggerName = nullptr )

inline

Converts the given startTime and invokes#SetStartTime(Ticks,const NString&).

Note: Microsoft Windows specific.

Parameters

startTime	The new start time in system specific time unit.
loggerName	The name of the Logger whose start time is to be set (case insensitive). Defaults to empty string, which indicates that all loggers are to be affected.

Definition at line 769 of file lox.inl.

Here is the call graph for this function:

◆ SetStartTime() [2/3]

void SetStartTime	(	Ticks	startTime = time::Ticks (),
		const NString &	loggerName = nullptr )

inline

This method is used reset (or to explicitly set) the start time of one or all logger(s). The only impact is the output of time differences in the log lines. Hence, this method is useful to reset them and see some absolute time values when doing basic performance tests using the Logger.

Note: This affects loggers that are registered for at least one standard domain. In other words, loggers that are exclusively attached to the internal domain, will not be affected.

Parameters

startTime	Optional parameter with the new start time. Defaults to current time if omitted.
loggerName	The name of the Logger(s) whose start time is to be set (case insensitive). Defaults to nullptr, which indicates that all loggers are to be affected.

Definition at line 733 of file lox.inl.

Here is the call graph for this function:

◆ SetStartTime() [3/3]

void SetStartTime	(	time_t	startTime,
		const NString &	loggerName = nullptr )

inline

Converts the given startTime and invokes SetStartTime(Ticks,const NString&).

Note: GLib specific.

Parameters

startTime	The new start time in system specific time unit.
loggerName	The name of the Logger whose start time is to be set (case insensitive). Defaults to empty string, which indicates that all loggers are to be affected.

Definition at line 750 of file lox.inl.

Here is the call graph for this function:

◆ SetVerbosity() [1/2]

void SetVerbosity	(	const NString &	loggerName,
		Verbosity	verbosity,
		const NString &	domain = "/",
		Priority	priority = Priority::Standard )

inline

Same as SetVerbosity but addressing the Logger to manipulate by its name.
This method may only be used after a Logger was once 'registered' with this Lox using SetVerbosity.

Parameters

loggerName	The logger to be to be affected, identified by its name (case insensitive).
verbosity	The 'level of verboseness' to be set.
domain	The parent (start) domain to be set. The use of absolute paths starting with `'/'` are recommended. Defaults to root domain "/".
priority	The priority of the setting. Defaults to Standard.

Definition at line 432 of file lox.inl.

Here is the call graph for this function:

◆ SetVerbosity() [2/2]

void SetVerbosity	(	detail::Logger *	logger,
		Verbosity	verbosity,
		const NString &	domain = "/",
		Priority	priority = Priority::Standard )

inline

Sets the Verbosity of the Log Domain which is evaluated from parameter domain and applicable Scope Domains. The verbosity given is set recursively for all Subdomains.

With the first invocation of this method for a distinct logger, this Logger is registered with this Lox. In this case, before setting the given Verbosity for the evaluated subdomain, the Verbosity for all domains is set to Verbosity::Off.

To deregister a Logger with a Lox, use method RemoveLogger. To 'disable' a Logger, invoke this method with parameters verbosity equaling to Verbosity::Off and domain to "/".

Optional parameter priority defaults to Standard, which is a lower priority than those of the standard plug-ins of external configuration data. Therefore, external configuration by default 'overwrite' settings made from 'within the source code', which simply means by invoking this method.
The parameter can be provided for two main reasons:

To 'lock' a verbosity setting against external manipulation.
to 'break' the standard mechanism that an invocation of this method sets all Subdomains recursively. If a subdomain was set with a higher priority (e.g., Config::PriorityOf(Priority::Standard) + 1, then this subdomain will not be affected by future invocations of this method with standard-priority given.

For more information on how to use external configuration variables with priority and on protecting verbosity settings, consult the ALib Module ALox - Programmer's Manual.

Attention: The same as with most interface methods of this class, the given domain parameter is combined with Scope Domains set for the caller's Scope. In standard use cases of ALox, the Verbosity of a Domain is set using absolute domain path addressing. Therefore, it is recommended to have any domain path passed to this method starting with '/', which suppresses the concatenation of Scope Domains.
This is why this parameter with this method defaults to '/', while with other methods of this class, it defaults to an empty string.; Even when using an absolute domain path, Scope Domains of Scope::ThreadInner, will still apply. This means that from within a thread that has such Scope Domain set, this method is (almost) not usable! This all aligns with the concept (advice), that Loggers and their Verbosity are generally set outside of such scopes, hence in configuration sections of a process.; Consequently, this method may be (mis-) used to modify the 'actual' (default) scope when explicitly giving an empty string with parameter domain. This is useful, to temporarily adjust a scope. But remember: ALox was designed to avoid temporary code lines...

Parameters

logger	The logger to be to be affected (case insensitive).
verbosity	The 'level of verboseness' to be set.
domain	The parent (start) domain to be set. The use of absolute paths starting with `'/'` are recommended. Defaults to root domain "/".
priority	The priority of the setting. Defaults to Standard.

Definition at line 407 of file lox.inl.

Here is the call graph for this function:

◆ State()

void State	(	const NString &	domain,
		Verbosity	verbosity,
		const String &	headLine,
		StateInfo	flags = StateInfo::All )

inline

This method logs the current configuration of this Lox and its encapsulated objects. It uses method GetState to assemble the logable string.

Note: As an alternative to (temporarily) adding an invocation of Lox.State to your code, ALox provides configuration variableALOX/LOXNAME/DUMP_STATE_ON_EXIT. This allows enabling an automatic invocation of this method using external configuration data like command line parameters, environment variables or INI files.

Parameters

domain	Optional Log Domain which is combined with Scope Domains set for the Scope of invocation.
verbosity	The verbosity.
headLine	If given, a separated headline will be logged at first place.
flags	Flag bits that define which state information is logged.

Definition at line 895 of file lox.inl.

Here is the call graph for this function:

◆ Store() [1/2]

void Store	(	const Box &	data,
		const NString &	key,
		Scope	scope = Scope::Global )

inline

Stores data encapsulated in an object of class Box which can be retrieved back by invoking Retrieve. Using the optional key and scope offer various possibilities to reference this data later.

To remove data from the store, pass nullptr with parameter data.

Attention: When data objects are 'overwritten', previous objects will be deleted internally. Hence, only pointers to heap-allocated objects (created with new) may be passed!
For more information, consult chapter 8 Log Data (Debug Variables) of the Programmer's Manual.

Note: Log Data is a feature provided by ALox to support debug-logging. It is not advised to use Log Data to implement application logic.

Parameters

data	The data object to store. If `nullptr`, currently stored data will be removed. In C++, has to be heap allocated and will be deleted by this Lox when overwritten or this lox is deleted.
key	The optional key to the data. If omitted (or empty or nullptr), the data is bound to the Scope provided. If omitted and scope is Scope::Global, then the data is unique to the Lox.
scope	The Scope that the data is bound to.

Definition at line 819 of file lox.inl.

Here is the call graph for this function:

◆ Store() [2/2]

void Store	(	const Box &	data,
		Scope	scope = Scope::Global )

inline

Overloaded version of Store(const Box&,const String&,Scope,int) "Store" which omits parameter key.

Parameters

data	The data object to store. In C++, has to be heap allocated and will be deleted by this Lox when overwritten or this lox is deleted.
scope	The Scope that the data is bound to.

Definition at line 832 of file lox.inl.

Here is the call graph for this function:

◆ Verbose()

template<typename... BoxedObjects>

void Verbose ( BoxedObjects &&... logables )

inline

Logs given logables using Verbosity::Verbose.

The first object provided may be a domain name. All values are passed to EntryDetectDomain. See documentation of this method for information on how to avoid ambiguities in respect to domain names.

If one of the arguments (or a single argument given) is of type alib::boxing,TBoxes "boxing,TBoxes", then the contents of this list is inserted into the list of logables. This allows collecting logables before invoking the method.

Parameters

logables The list of Logables, optionally including a domain name at the start.

Definition at line 1012 of file lox.inl.

Here is the call graph for this function:

◆ Warning()

template<typename... BoxedObjects>

void Warning ( BoxedObjects &&... logables )

inline

Logs given logables using Verbosity::Warning.

The first object provided may be a domain name. All values are passed to EntryDetectDomain. See documentation of this method for information on how to avoid ambiguities in respect to domain names.

If one of the arguments (or a single argument given) is of type alib::boxing,TBoxes "boxing,TBoxes", then the contents of this list is inserted into the list of logables. This allows collecting logables before invoking the method.

Parameters

logables The list of Logables, optionally including a domain name at the start.

Definition at line 1052 of file lox.inl.

Here is the call graph for this function:

The documentation for this class was generated from the following files:

Description:

Public Static Field Index:

Public Static Method Index:

Public Method Index:

Protected Field Index:

Field Details:

◆ impl

◆ InternalDomains

Constructor(s) / Destructor Details:

◆ Lox()

◆ ~Lox()

Method Details:

◆ Acquire()

◆ Assert()

◆ ClearSourcePathTrimRules()

◆ CreateConsoleLogger()

◆ DbgGetMonoAllocator()

◆ Entry()

◆ EntryDetectDomain()

◆ Error()

◆ GetLogableContainer()

◆ GetLogCounter()

◆ GetLogger()

◆ GetName()

◆ GetState()

◆ If() [1/2]

◆ If() [2/2]

◆ Info()

◆ IsActive()

◆ MapThreadName()

◆ Once() [1/10]

◆ Once() [2/10]

◆ Once() [3/10]

◆ Once() [4/10]

◆ Once() [5/10]

◆ Once() [6/10]

◆ Once() [7/10]

◆ Once() [8/10]

◆ Once() [9/10]

◆ Once() [10/10]

◆ Release()

◆ RemoveLogger() [1/2]

◆ RemoveLogger() [2/2]

◆ RemoveThreadDomain()

◆ Reset()

◆ Retrieve() [1/2]

◆ Retrieve() [2/2]

◆ SetDomain() [1/2]

◆ SetDomain() [2/2]

◆ SetDomainSubstitutionRule()

◆ SetFileNameCacheCapacity()

◆ SetPrefix() [1/3]

◆ SetPrefix() [2/3]

◆ SetPrefix() [3/3]

◆ SetSourcePathTrimRule()

◆ SetStartTime() [1/3]

◆ SetStartTime() [2/3]

◆ SetStartTime() [3/3]

◆ SetVerbosity() [1/2]

◆ SetVerbosity() [2/2]

◆ State()

◆ Store() [1/2]

◆ Store() [2/2]

◆ Verbose()

◆ Warning()