Description:

This namespace holds types and functions, which are very close to the C++ language itself. The availability of most of the entities found here, is not related to the inclusion of a certain ALib Module within the ALib Distribution chosen. Instead, the corresponding header files are always included when compiling ALib.

With the inclusion of ALib BaseCamp in the ALib Distribution, type Camp is found, which is used to organize the library in respect to resource management and bootstrapping. Furthermore, this very special "Camp-Module" adds sub-namespaces

to this namespace, as well as a few other basic language-related types like lang::Exception.

Reference Documentation

Nested Namespaces:
namespace	basecamp

namespace	detail
	Internal details of namespace alib::lang.

namespace	format

namespace	resources

namespace	system
	This is the reference documentation of sub-namespace system of module ALib BaseCamp.

Type Index:
struct	Allocator

struct	AllocatorInterface

struct	AllocatorMember

struct	AllocatorMember< HeapAllocator >

struct	BidiListHook

struct	BidiNodeBase

struct	CallerInfo

class	Camp

struct	DbgAlloc

struct	DbgCriticalSections

class	DbgTypeDemangler

struct	ERException

class	Exception

struct	HeapAllocator

struct	Message

class	Owner

class	OwnerRecursive

class	OwnerShared

class	OwnerSharedTimed

class	OwnerTimed

class	OwnerTry

class	OwnerTryShared

struct	Placeholder

class	Plugin

class	PluginContainer

class	Report

class	ReportWriter

class	ReportWriterStdIO

struct	RTTRAllocator

struct	SidiListHook

struct	SidiNodeBase

struct	StdContainerAllocator

struct	StdContainerAllocatorRecycling

class	TBitSet

struct	TMPUnknownType

Type Definition Index:
using	integer = platform_specific

using	intGap_t = platform_specific

using	uinteger = platform_specific

using	uintGap_t = platform_specific

Enumeration Index:
enum class	Alignment { Left , Right , Center }
	Denotes Alignments. More...

enum class	Bool : bool { False , True }

enum class	Caching { Disabled , Enabled , Auto }
	Denotes if a cache mechanism is enabled or disabled. More...

enum class	Case : bool { Sensitive , Ignore }
	Denotes upper and lower case character treatment. More...

enum class	ContainerOp { Insert , Remove , Get , GetCreate , Create }
	Denotes standard container operations. More...

enum class	CreateDefaults : bool { No , Yes }
	Denotes whether default entities should be created or not. More...

enum class	CreateIfNotExists : bool { No , Yes }
	Denotes whether something should be created if it does not exist. More...

enum class	CurrentData : bool { Keep , Clear }

enum class	Inclusion : bool { Include , Exclude }
	Denotes how members of a set something should be taken into account. More...

enum class	Initialization { Suppress , Default , Nulled }
	Used for example with constructors that allow to suppress initialization of members. More...

enum class	Phase { Begin = (1 << 0) , End = (1 << 1) }
	Denotes a phase, e.g.,of a transaction. More...

enum class	Propagation : bool { Omit , ToDescendants }
	Denotes whether a e.g a setting should be propagated. More...

enum class	Reach : bool { Global , Local }
	Denotes the reach of something. More...

enum class	Recursive : bool { No , Yes }
	Denotes whether recursion is performed/allowed or not. More...

enum class	ReportExceptions { ErrorWritingReport = 1 }
	Exception codes of class Report. More...

enum class	Responsibility : bool { KeepWithSender , Transfer }

enum class	Safeness : bool { Safe , Unsafe }
	Denotes whether something should be performed in a safe or unsafe fashion. More...

enum class	Side : bool { Left , Right }
	Denotes if something is left or right. More...

enum class	SortOrder : bool { Ascending , Descending }
	Denotes sort order. More...

enum class	SourceData : bool { Copy , Move }
	Denotes if the source data should be moved or copied. More...

enum class	Switch : bool { Off , On }
	Denotes if sth. is switched on or off. More...

enum class	Timezone : bool { Local , UTC }
	Denotes whether a time value represents local time or UTC. More...

enum class	Timing { Async , Sync }
	Denotes if asynchronous tasks become synchronized. More...

enum class	ValueReference { Absolute , Relative }
	Denotes if a value is interpreted as an absolute or relative number. More...

enum class	Whitespaces : bool { Trim , Keep }
	Denotes whether a string is trimmed or not. More...

Function Index:
template<typename TIntegral >
constexpr int	BitCount (TIntegral value)

template<typename T >
constexpr int	bitsofval (const T &val)

template<typename TIntegral >
constexpr int	CLZ (TIntegral value)

template<typename TIntegral >
constexpr int	CLZ0 (TIntegral value)

template<typename TIntegral >
constexpr int	CTZ (TIntegral value)

template<typename TIntegral >
constexpr int	CTZ0 (TIntegral value)

ALIB_API void	DbgSimpleALibMsg (const CallerInfo &ci, int type, const char topic, const char msg, const int intValue)

ALIB_API void	DbgSimpleALibMsg (const CallerInfo &ci, int type, const char topic, const char msg1=nullptr, const char msg2=nullptr, const char msg3=nullptr, const char msg4=nullptr, const char msg5=nullptr)

ALIB_WARNINGS_ALLOW_UNSAFE_BUFFER_USAGE void	debugReportPlugin (const CallerInfo &ci, int type, const char topic, int qtyMsgs, const nchar *msgs)

template<typename T >
static ALIB_FORCE_INLINE void	Destruct (T &object)

template<typename T >
constexpr bool	IsNotNull (const T &t)

template<typename T >
constexpr bool	IsNull (const T &t)

template<typename TIntegral >
constexpr int	Log2OfSize ()

template<typename TIntegral >
constexpr TIntegral	LowerBits (ShiftOpRHS width, TIntegral value)

template<ShiftOpRHS TWidth, typename TIntegral >
constexpr TIntegral	LowerBits (TIntegral value)

template<ShiftOpRHS TWidth, typename TIntegral >
constexpr TIntegral	LowerMask ()

template<typename TIntegral >
constexpr TIntegral	LowerMask (ShiftOpRHS width)

template<typename TIntegral >
constexpr int	MSB (TIntegral value)

template<typename TIntegral >
constexpr int	MSB0 (TIntegral value)

template<typename TTo , typename TFrom >
TTo *	SafeCast (TFrom *derived)

template<typename T >
constexpr void	SetNull (const T &t)

template<ShiftOpRHS TWidth, typename TIntegral >
constexpr TIntegral	UpperMask ()

template<typename TIntegral >
constexpr TIntegral	UpperMask (ShiftOpRHS width)

Variable Index:
unsigned int	DBG_CRITICAL_SECTION_YIELD_OR_SLEEP_TIME_IN_NS

void(*	DBG_SIMPLE_ALIB_MSG_PLUGIN )(const CallerInfo &ci, int type, const char topic, int qtyMsgs, const char *msgs) =nullptr

Type Definition Details:

◆ integer

using integer = platform_specific

This type specifies platform-independent integral values of the 'natural' bit-size of the underlying platform. In general, on 32-bit systems this will be 32-bit wide, on 64-bit systems, 64-bits. Hence, on standard architectures, it has the same bit-size and signedness as std::ptrdiff_t.

The type can be considered as a signed version of std::size_t. It is needed because standard type 'int' is not specified in respect to its size. E.g., GNU C++ and Clang compiler use 32-Bit integers for type int, even on 64-Bit platforms.

◆ intGap_t

using intGap_t = platform_specific

This type, together with its counterpart alib::uintGap_t is used to fill a gap that occurs when method overloads or template specialization are needed for integer types. The rationale behind and use of this pair of types is best explained with a sample.

Consider the following code:

// Template function
template <typename TInteger> const char* MyFunc(TInteger val) { return "NOT IMPLEMENTED"; }
 
// Specializations for integer types
template<> const char* MyFunc(  int8_t  ) { return "Type=  int8_t "; }
template<> const char* MyFunc( uint8_t  ) { return "Type= uint8_t "; }
template<> const char* MyFunc(  int16_t ) { return "Type=  int16_t"; }
template<> const char* MyFunc( uint16_t ) { return "Type= uint16_t"; }
template<> const char* MyFunc(  int32_t ) { return "Type=  int32_t"; }
template<> const char* MyFunc( uint32_t ) { return "Type= uint32_t"; }
template<> const char* MyFunc(  int64_t ) { return "Type=  int64_t"; }
template<> const char* MyFunc( uint64_t ) { return "Type= uint64_t"; }
 
// TestMethod
void test()
{
    // test std int types
    cout << " int8_t           : " << MyFunc( ( int8_t )           0 ) << endl; // OK
    cout << "uint8_t           : " << MyFunc( (uint8_t )           0 ) << endl; // OK
    cout << " int16_t          : " << MyFunc( ( int16_t)           0 ) << endl; // OK
    cout << "uint16_t          : " << MyFunc( (uint16_t)           0 ) << endl; // OK
    cout << " int32_t          : " << MyFunc( ( int32_t)           0 ) << endl; // OK
    cout << "uint32_t          : " << MyFunc( (uint32_t)           0 ) << endl; // OK
    cout << " int64_t          : " << MyFunc( ( int64_t)           0 ) << endl; // OK
    cout << "uint64_t          : " << MyFunc( (uint64_t)           0 ) << endl; // OK
    cout << endl;
 
    // test 'language' types
    cout << "         long     : " << MyFunc( (         long     ) 0 ) << endl; // Gap on common 32-bit platforms and 64-bit MSVC
    cout << "unsigned long     : " << MyFunc( (unsigned long     ) 0 ) << endl; // Gap on common 32-bit platforms and 64-bit MSVC
    cout << endl;
    cout << "         long long: " << MyFunc( (         long long) 0 ) << endl; // Gap on 64-Bit GNU C++
    cout << "unsigned long long: " << MyFunc( (unsigned long long) 0 ) << endl; // Gap on 64-Bit GNU C++
    cout << endl;
 
    // further info
    cout << endl;
    cout << "sizeof(         long     )= " << sizeof(         long     ) << endl;
    cout << "sizeof(unsigned long     )= " << sizeof(unsigned long     ) << endl;
    cout << endl;
    cout << "sizeof(         long long)= " << sizeof(         long long) << endl;
    cout << "sizeof(unsigned long long)= " << sizeof(unsigned long long) << endl;
}
 

When this is run under 64 Bit - Linux, GNU compiler, the following output is produced:

 int8_t           : Type=  int8_t 
uint8_t           : Type= uint8_t 
 int16_t          : Type=  int16_t
uint16_t          : Type= uint16_t
 int32_t          : Type=  int32_t
uint32_t          : Type= uint32_t
 int64_t          : Type=  int64_t
uint64_t          : Type= uint64_t

         long     : Type=  int64_t
unsigned long     : Type= uint64_t

         long long: NOT IMPLEMENTED
unsigned long long: NOT IMPLEMENTED


sizeof(         long     )= 8
sizeof(unsigned long     )= 8

sizeof(         long long)= 8
sizeof(unsigned long long)= 8

This is not what many C++ programmers would expect: Although type long long is the same 64-bit type as long, the template method is not seen as specialized by the compiler. Therefore, we have a "gap" in the definition of specializations for types long long and unsigned long long.

When compiling and running the same sample code under GNU compiler 32-bit or under MSVC (Microsoft compiler), 32 or 64-bit, then the gap "moves" to be with types long and unsigned long instead. Here, this hurts a lot, because code that uses a simple integer constant 1L is not fetched by the template specializations!

The lesson learned is that two more specializations are needed and that their types are dependent on the compiler and library used. Because it is not allowed to specialize simply with all possible extra variants (this would lead to doubly defined methods), a preprocessor switch that chooses the right types to fill the gap is needed.

This type, together with uintGap_t, does exactly this: using the preprocessor to select the right "missing" type.

To fix the sample above, the following two specializations of the template method need to be added:

template<> const char* MyFunc( alib:: intGap_t ) { return "Type= intGap_t"; }

template<> const char* MyFunc( alib::uintGap_t ) { return "Type= uintGap_t"; }

When overloading functions with integer types, similar rules apply: To have the complete set of integer types covered, 10 overloads are needed: from type int8_t to type int64_t, type intGap_t and then those five types in two versions, signed and unsigned. Only with all overloads in place, compiler warnings (on high warning levels), compiler errors due to ambiguouties and/or the necessity of explicit type conversions are avoided.

See also: Along with these definitions, preprocessor symbol ALIB_SIZEOF_INTGAP is defined.

Definition at line 95 of file integers.hpp.

◆ uinteger

using uinteger = platform_specific

Unsigned version of alib::integer. This type should be the same as std::size_t on all platforms.

Definition at line 47 of file integers.hpp.

◆ uintGap_t

using uintGap_t = platform_specific

Used to complete overwriting methods and template specializations.
See signed sibling type alib::intGap_t for more information.

Definition at line 99 of file integers.hpp.

Enumeration Details:

◆ Alignment

enum class Alignment

strong

Denotes Alignments.

Enumerator
Left	Chooses left alignment.
Right	Chooses right alignment.
Center	Chooses centered alignment.

Definition at line 29 of file commonenumdefs.hpp.

◆ Bool

enum class Bool : bool

strong

Enumeration representing a boolean value. While the use of this enumeration type seems senseless at the first sight (as the C++ has keywords bool, false and true), the reason for its existence is to have write and parse methods in place using the concept of ALib Enum Records.

The default name translation table is equipped with various 'overloaded' element entries like "yes", "no", "on", "off", "1" or "0". Furthermore, if other languages should be supported, this can even be extended at run-time.

Enumerator
False	False value.
True	True value.

Definition at line 46 of file commonenumdefs.hpp.

◆ Caching

enum class Caching

strong

Denotes if a cache mechanism is enabled or disabled.

Enumerator
Disabled	Caching is disabled.
Enabled	Caching is enabled.
Auto	Auto/default mode.

Definition at line 55 of file commonenumdefs.hpp.

◆ Case

enum class Case : bool

strong

Denotes upper and lower case character treatment.

Enumerator
Sensitive	Chooses an operation mode which differs between lower and upper case letters (usually the default).
Ignore	Chooses an operation mode which does not differ between between lower and upper case letters.

Definition at line 66 of file commonenumdefs.hpp.

◆ ContainerOp

enum class ContainerOp

strong

Denotes standard container operations.

Enumerator
Insert	Denotes insertions.
Remove	Denotes removals.
Get	Denotes to search data.
GetCreate	Denotes to create data if not found.
Create	Denotes to create data.

Definition at line 78 of file commonenumdefs.hpp.

◆ CreateDefaults

enum class CreateDefaults : bool

strong

Denotes whether default entities should be created or not.

Enumerator
No	Do not create.
Yes	Create default values.

Definition at line 90 of file commonenumdefs.hpp.

◆ CreateIfNotExists

enum class CreateIfNotExists : bool

strong

Denotes whether something should be created if it does not exist.

Enumerator
No	Do not create.
Yes	Create if something does not exist.

Definition at line 99 of file commonenumdefs.hpp.

◆ CurrentData

enum class CurrentData : bool

strong

Denotes if current, existing data should be cleared or if new data should be appended or otherwise added.

Enumerator
Keep	Chooses not no clear existing data.
Clear	Chooses to clear existing data.

Definition at line 109 of file commonenumdefs.hpp.

◆ Inclusion

enum class Inclusion : bool

strong

Denotes how members of a set something should be taken into account.

Enumerator
Include	Chooses inclusion.
Exclude	Chooses exclusion.

Definition at line 118 of file commonenumdefs.hpp.

◆ Initialization

enum class Initialization

strong

Used for example with constructors that allow to suppress initialization of members.

Enumerator
Suppress	Suppress initialization. Writes "Suppress", reads in addition "None".
Default	Perform default initialization. Writes "Default", reads in addition "Initialize".
Nulled	Perform initialization with a nulled value. Writes "Nulled", reads in addition "Zero".

Definition at line 127 of file commonenumdefs.hpp.

◆ Phase

enum class Phase

strong

Denotes a phase, e.g.,of a transaction.

Enumerator
Begin	The start of a transaction.
End	The end of a transaction.

Definition at line 140 of file commonenumdefs.hpp.

◆ Propagation

enum class Propagation : bool

strong

Denotes whether a e.g a setting should be propagated.

Enumerator
Omit	Do not propagate changes.
ToDescendants	Propagate changes to descendants/children/subcomponents.

Definition at line 149 of file commonenumdefs.hpp.

◆ Reach

enum class Reach : bool

strong

Denotes the reach of something.

Enumerator
Global	Denotes global reach.
Local	Denotes local reach.

Definition at line 158 of file commonenumdefs.hpp.

◆ Recursive

enum class Recursive : bool

strong

Denotes whether recursion is performed/allowed or not.

Enumerator
No	Denotes non-recursive.
Yes	Denotes recursion.

Definition at line 167 of file commonenumdefs.hpp.

◆ ReportExceptions

enum class ReportExceptions

strong

Exception codes of class Report.

Enumerator
ErrorWritingReport	Error when writing a report. This typically indicates an erroneous format string in an ALIB_ASSERT_ERROR or related macro.

Definition at line 31 of file report.hpp.

◆ Responsibility

enum class Responsibility : bool

strong

Denotes whether the responsibility for something is kept or passed. This is useful, e.g., in situations where objects are shared to determine if the responsibility for the deletion of object is transferred over to the receiver or kept by the sender of the object.

Enumerator
KeepWithSender	Keeps responsibility, e.g., when passing an object.
Transfer	Transfers responsibility to the receiving party.

Definition at line 178 of file commonenumdefs.hpp.

◆ Safeness

enum class Safeness : bool

strong

Denotes whether something should be performed in a safe or unsafe fashion.

Enumerator
Safe	Do it or treat it with safety.
Unsafe	Omit checks or perform unsafe operations.

Definition at line 187 of file commonenumdefs.hpp.

◆ Side

enum class Side : bool

strong

Denotes if something is left or right.

Enumerator
Left	Denotes the left side of something.
Right	Denotes the right side of something.

Definition at line 196 of file commonenumdefs.hpp.

◆ SortOrder

enum class SortOrder : bool

strong

Denotes sort order.

Enumerator
Ascending	Chooses ascending sort oder.
Descending	Chooses descending sort oder.

Definition at line 205 of file commonenumdefs.hpp.

◆ SourceData

enum class SourceData : bool

strong

Denotes if the source data should be moved or copied.

Enumerator
Copy	Chooses not to clear existing data.
Move	Chooses to clear existing data.

Definition at line 214 of file commonenumdefs.hpp.

◆ Switch

enum class Switch : bool

strong

Denotes if sth. is switched on or off.

Enumerator
Off	Switch it off, switched off, etc.
On	Switch it on, switched on, etc.

Definition at line 223 of file commonenumdefs.hpp.

◆ Timezone

enum class Timezone : bool

strong

Denotes whether a time value represents local time or UTC.

Enumerator
Local	Denotes local time.
UTC	Denotes UTC (coordinated universal time).

Definition at line 232 of file commonenumdefs.hpp.

◆ Timing

enum class Timing

strong

Denotes if asynchronous tasks become synchronized.

Enumerator
Async	The end of a transaction. Writes "Async", reads in addition "asynchronous", "no", "off", "false", "0" "-".
Sync	The start of a transaction. Writes "Sync", reads in addition "synchronous", "synchronized", "synced" "yes", "on", "true", "1".

Definition at line 241 of file commonenumdefs.hpp.

◆ ValueReference

enum class ValueReference

strong

Denotes if a value is interpreted as an absolute or relative number.

Enumerator
Absolute	Referring to an absolute value.
Relative	Referring to a relative value.

Definition at line 253 of file commonenumdefs.hpp.

◆ Whitespaces

enum class Whitespaces : bool

strong

Denotes whether a string is trimmed or not.

Enumerator
Trim	Trim whitespaces away.
Keep	Keep whitespaces in string.

Definition at line 262 of file commonenumdefs.hpp.

Function Details:

◆ BitCount()

template<typename TIntegral >

int BitCount ( TIntegral value )

constexpr

Returns the number of bits set in an integral value. Internally, this method uses:

On gcc/clang: builtin method __builtin_popcount (and variations) which translate to a single assembly instruction, and a constexpression in case value is known at compile-time.
With MS-compilers, intrinsic popcount is used.
On other platforms, the number is evaluated programmatically.

Template Parameters

TIntegral The integral type to operate on.

Parameters

value The value to test.

Returns: The number of bits set in a value.

◆ bitsofval()

template<typename T >

int bitsofval ( const T & val )

inlineconstexpr

Like C++ keyword sizeof but returns the number of bits of the type of the given value. The return type is int instead of size_t, which satisfies ALib code conventions.

Note: To improve code readability, namely to a) indicate that this is an inlined, constant expression and b) to indicate that this is just using keyword sizeof, as an exception from the rules, this function is spelled in lower case.

See also: Macro bitsof(type), which works directly on the type.

Parameters

val	The (sample) value to deduce the type from. Otherwise ignored.

Template Parameters

T	The type to receive the size in bits from.

Returns: The size of TIntegral in bits.

Definition at line 63 of file bits.hpp.

◆ CLZ()

template<typename TIntegral >

int CLZ ( TIntegral value )

constexpr

Returns the number of the leading 0-bits in an integral type. Internally, this method uses:

On gcc/clang: builtin methods __builtin_clz (or variations) which translate to a single assembly instruction, and a constexpression in case value is known at compile-time.
With MS-compilers, intrinsics _BitScanReverse or _BitScanReverse64 is used.
On other platforms, a binary search is performed.

Attention: This function must not be called with a value of 0! In debug-compilations, this method raises an ALib assertion in this case, while in release-compilations, the result is 'undefined'. With function MSB0, an alternative is given which returns 0 if the input is 0.

Template Parameters

TIntegral The integral type to operate on.

Parameters

value The value to test. Must not be 0.

Returns: The highest bit set in value.

◆ CLZ0()

template<typename TIntegral >

int CLZ0 ( TIntegral value )

constexpr

Variant of CLZ which tests given parameter value on 0 and returns sizeof(TIntegral) * 8 in this case. Otherwise, returns the result of CLZ.

Template Parameters

TIntegral The integral type to operate on.

Parameters

value The value to test. May be 0, which results to the number of bits in TIntegral.

Returns: The number of leading zero-bits in value.

◆ CTZ()

template<typename TIntegral >

int CTZ ( TIntegral value )

constexpr

Returns the number of the trailing 0-bits in an integral type. Internally, this method uses:

On gcc/clang: builtin methods __builtin_ctz (and variations) which translate to a single assembly instruction, and a constexpression in case value is known at compile-time.
With MS-compilers, intrinsics _BitScanForward or _BitScanForward64 is used.
On other platforms, a binary search is performed.

Attention: This function must not be called with a value of 0! In debug-compilations, this method raises an ALib assertion in this case, while in release-compilations, the result is 'undefined'. With function CTZ0, an alternative is given which returns 0 if the input is 0.

Template Parameters

TIntegral The integral type to operate on.

Parameters

value The value to test. Must not be 0.

Returns: The lowest bit set in value.

◆ CTZ0()

template<typename TIntegral >

int CTZ0 ( TIntegral value )

constexpr

Variant of CTZ which tests given parameter value on 0 and returns sizeof(TIntegral) * 8 in this case. Otherwise, returns the result of CLZ.

Template Parameters

TIntegral The integral type to operate on.

Parameters

value The value to test. May be 0, which results to the number of bits in TIntegral.

Returns: The number of trailing zero-bits in value. In case the given value is 0, sizeof(Tintegral) * 8 is returned.

◆ DbgSimpleALibMsg() [1/2]

ALIB_API void DbgSimpleALibMsg	(	const CallerInfo &	ci,
		int	type,
		const char *	topic,
		const char *	msg,
		const int	intValue )

extern

Overloaded version of DbgSimpleALibMsg which accepts one integral value and writes msg and intValue in sequence.

Parameters

ci	Caller information.
type	The type of the message. The default implementation does not use this, other than invoking `assert(0)` in the case this parameter equals `0`.
topic	The topic of the report.
msg	The message string.
intValue	An integer parameter (optional due to overload).

◆ DbgSimpleALibMsg() [2/2]

ALIB_API void DbgSimpleALibMsg	(	const CallerInfo &	ci,
		int	type,
		const char *	topic,
		const char *	msg1 = nullptr,
		const char *	msg2 = nullptr,
		const char *	msg3 = nullptr,
		const char *	msg4 = nullptr,
		const char *	msg5 = nullptr )

extern

Some ALib modules do not (must not) rely on Report / ReportWriter mechanics. Therefore, this simple method is used for error handling in those portions of ALib that are exposed in such modules.
This method first checks if static function pointer lang::DBG_SIMPLE_ALIB_MSG_PLUGIN is set and if yes, passes the parameters to this method and exits. If the module ALib BaseCamp is included in the ALib Distribution, method BaseCamp::bootstrap sets this plug-in function to a custom one which passes the message(s) to a proper ALib Report.

Otherwise, the method just writes to the standard output stream and then, if type equals 0, invokes assert(0).

Parameters

ci	Caller information.
type	The type of the message. The default implementation does not use this, other than invoking `assert(0)` in the case this parameter equals `0`.
topic	The topic of the message.
msg1	The first message string.
msg2	Optional 2nd message string.
msg3	Optional 3rd message string.
msg4	Optional 4th message string.
msg5	Optional 5th message string.

◆ debugReportPlugin()

ALIB_WARNINGS_ALLOW_UNSAFE_BUFFER_USAGE void debugReportPlugin	(	const CallerInfo &	ci,
		int	type,
		const char *	topic,
		int	qtyMsgs,
		const nchar **	msgs )

This method is installed with lang::DBG_SIMPLE_ALIB_MSG_PLUGIN in method Camp::bootstrap.

The message strings are simply passed to the default Report. This way, the essential assert, error and message macros are using the ALib report system at the moment that the ALib BaseCamp is included in the ALib Distribution.

Parameters

ci	Information about the scope of invocation.
type	The type of message. See Message.
topic	The topic of message.
qtyMsgs	The number of messages in msgs.
msgs	A list of strings (this is all that the essential versions of ALib reporting macros provide).

Definition at line 98 of file basecamp.cpp.

Here is the call graph for this function:

◆ Destruct()

template<typename T >

static ALIB_FORCE_INLINE void Destruct ( T & object )

static

This static inline namespace function calls the destructor ~T()of given object. The use of this method is recommended instead of calling the destructor directly, to increase readability of the code.

Attention: Pointers have to be dereferenced when passed as arguments. Otherwise, this method does nothing, as the "destructor of a pointer" is called.
Because, for example, container types would pass a pointer here, in case their (custom) stored type is a pointer type, no static assertion can be made here.

Template Parameters

T	The object type. Deduced by the compiler and not need to be given.

Parameters

object The object to destruct.

Definition at line 729 of file allocation.hpp.

◆ IsNotNull()

template<typename T >

bool IsNotNull ( const T & t )

inlineconstexpr

The negation of alib::lang::IsNull.

Parameters

t	The instance to test.

Returns: false if t is default-constructed, true otherwise.

Definition at line 1054 of file alib.hpp.

◆ IsNull()

template<typename T >

bool IsNull ( const T & t )

inlineconstexpr

Checks if a given object equals a default-constructed value of the same type. This function is useful with types that are not otherwise testable, for example, type std::thread::id.

Parameters

t	The instance to test.

Returns: true if t is default-constructed, false otherwise.

◆ Log2OfSize()

template<typename TIntegral >

int Log2OfSize ( )

inlineconstexpr

Returns the logarithm base 2 for the size in bits of the template given integral type.

Precisely, this function returns:

3 for 8-bit types,
4 for 16-bit types,
5 for 32-bit types,
6 for 64-bit types and
7 for 128-bit types.
Template Parameters

TIntegral The integral type to count bits in.

Returns
The number of bits needed to count the bits of type TIntegral.

◆ LowerBits() [1/2]

template<typename TIntegral >

TIntegral LowerBits	(	ShiftOpRHS	width,
		TIntegral	value )

inlineconstexpr

Inline namespace function that keeps the given number of lower bits and masks the higher ones out of the given integral value. Parameter width must not be greater or equal to the width of the given TIntegral type. In debug compilations, an assertion is raised.

See also: A fully templated version usable when the number of bits are known at compile time, is given with LowerBits<ShiftOpRHS,TIntegral>().

Parameters

width	The number of lower bits to keep.
value	The value to mask.

Template Parameters

TIntegral The integral type to operate on (deduced by the compiler).

Returns: The given value with the upper remaining bits cleared.

◆ LowerBits() [2/2]

template<ShiftOpRHS TWidth, typename TIntegral >

TIntegral LowerBits ( TIntegral value )

inlineconstexpr

Inline namespace function that keeps the given number of lower bits and masks the higher ones out of the given integral value. If parameter TWidth is greater or equal to the width of the given TIntegral type, then all bits are returned.

See also: While this is the fully templated version and hence explicitly constexpression for the reader of a code, with alib::lang::LowerBits<TIntegral>(lang::ShiftOpRHS,TIntegral), a version is given.

Parameters

value The value to mask.

Template Parameters

TWidth	The number of lower bits to keep.
TIntegral	The integral type to operate on (deduced by the compiler).

Returns: The given value with the upper remaining bits cleared.

◆ LowerMask() [1/2]

template<ShiftOpRHS TWidth, typename TIntegral >

TIntegral LowerMask ( )

inlineconstexpr

Inline namespace function that returns a mask with bits set to 1 up to the given binary digit, and bits above to 0. If parameter TWidth is greater or equal to the width of the given TIntegral type, then all bits are set in the returned value.

See also: While this is the fully templated version, with alib::lang::LowerMask<TIntegral>(ShiftOpRHS), a run-time version is given.

Template Parameters

TWidth	The number of lower bits to set to `1`.
TIntegral	The integral type to operate on.

Returns: The requested mask.

◆ LowerMask() [2/2]

template<typename TIntegral >

TIntegral LowerMask ( ShiftOpRHS width )

inlineconstexpr

Inline namespace function that returns a mask with bits set to 1 up to the given binary digit, and bits above to 0. Parameter width must not be greater or equal to the width of the given TIntegral type. In debug compilations, an assertion is raised in that case.

See also: A fully templated version usable when the number of bits are known at compile time, is given with LowerMask<ShiftOpRHS,typename>().

Template Parameters

TIntegral The integral type to operate on.

Parameters

width The number of lower bits to set in the mask returned.

Returns: The requested mask.

◆ MSB()

template<typename TIntegral >

int MSB ( TIntegral value )

constexpr

Returns the number of the most significant bit in an integral type. Internally, this method uses CLZ and returns

 int(sizeof(TIntegral)) * 8 - CLZ(value)

Attention: This function must not be called with a value of 0! In debug-compilations, this method raises an ALib assertion in this case, while in release-compilations, the result is 'undefined'. With function MSB0, an alternative is given which returns 0 if the input is 0.

Note: A corresponding function "LSB", to receive the least significant bit is not given. Instead, use CTZ() + 1.

Template Parameters

TIntegral The integral type to operate on.

Parameters

value The value to test. Must not be 0.

Returns: The highest bit set in value. The numbering starts with 1 and ends with sizeof(Tintegral) * 8.

◆ MSB0()

template<typename TIntegral >

int MSB0 ( TIntegral value )

constexpr

Variant of MSB which tests given parameter value on 0 and returns 0 in this case. Otherwise, returns the result of MSB.

Template Parameters

TIntegral The integral type to operate on.

Parameters

value The value to test. May be 0, which results to 0.

Returns: The highest bit set in value. The numbering starts with 1 and ends with sizeof(Tintegral)* 8. If value is 0, hence no bit is set, 0 is returned.

◆ SafeCast()

template<typename TTo , typename TFrom >

TTo * SafeCast ( TFrom * derived )

Cast function that chooses either static_cast or dynamic_cast, dependent on whether type TTo is polymorphic or not.

Template Parameters

TTo	The type to cast down to.
TFrom	The type to cast from.

Parameters

derived A pointer to the derived type.

Returns: A pointer to the base type.

Definition at line 103 of file tmp.hpp.

◆ SetNull()

template<typename T >

void SetNull ( const T & t )

inlineconstexpr

Assigns a default-constructed value to the given instance. This function is useful with types that are not otherwise nullable, for example, type std::thread::id.

Parameters

t	The instance to test.

◆ UpperMask() [1/2]

template<ShiftOpRHS TWidth, typename TIntegral >

TIntegral UpperMask ( )

inlineconstexpr

Inline namespace function that returns a mask with bits set to 0 up to the given binary digit, and bits above to 1. If parameter TWidth is greater or equal to the width of the given TIntegral type, then all bits are set in the returned value.

See also: While this is the fully templated version, with alib::lang::UpperMask<TIntegral>(ShiftOpRHS), a run-time version is given.

Template Parameters

TWidth	The number of lower bits to clear to `1`.
TIntegral	The integral type to operate on.

Returns: The requested mask.

◆ UpperMask() [2/2]

template<typename TIntegral >

TIntegral UpperMask ( ShiftOpRHS width )

inlineconstexpr

Inline namespace function that returns a mask with bits set to 0 up to the given binary digit, and bits above to 1. Parameter width must not be greater or equal to the width of the given TIntegral type. In debug compilations, an assertion is raised in that case.

See also: A fully templated version usable when the number of bits are known at compile time, is given with UpperMask<ShiftOpRHS,typename>().

Template Parameters

TIntegral The integral type to operate on.

Parameters

width The number of lower bits to clear in the mask returned.

Returns: The requested mask.

Variable Details:

◆ DBG_CRITICAL_SECTION_YIELD_OR_SLEEP_TIME_IN_NS

unsigned int DBG_CRITICAL_SECTION_YIELD_OR_SLEEP_TIME_IN_NS

extern

This external variable is available only if the compiler symbol ALIB_DEBUG_CRITICAL_SECTIONS is set and module ALib Threads is included in the ALib Distribution.
When it is 0, which is the default, nothing is done.
When it is 1, then Thread::YieldToSystem is invoked with interface methods of class DbgCriticalSections.
Other values are passed to a call to Thread::SleepNanos.

The purpose of this debug-feature is to be better able to detect non-protected concurrent access to critical sections. With increasing the time slice that a thread remains in a critical section, the probability to be caught by another thread is increased.

Definition at line 298 of file alib.cpp.

◆ DBG_SIMPLE_ALIB_MSG_PLUGIN

void(* DBG_SIMPLE_ALIB_MSG_PLUGIN)(const CallerInfo &ci, int type, const char topic, int qtyMsgs, const char *msgs)	(	const CallerInfo &	ci,
		int	type,
		const char *	topic,
		int	qtyMsgs,
		const char **	msgs ) =nullptr

This function pointer defaults to nullptr and may be set to replace function DbgSimpleALibMsg. With the use of ALib BaseCamp, the module's bootstrap code (precisely method BaseCamp::bootstrap) sets this pointer to a small method which creates an Report on the default ReportWriter.

ci: Information about the scope of invocation.
type: The type of the message. As a convention, 0 is severe error, others are warning levels.
qtyMsgs: The number of messages passed.
msgs: The message strings.

Definition at line 316 of file alib.cpp.

Description:

Reference Documentation

Nested Namespaces:

Type Index:

Type Definition Index:

Enumeration Index:

Function Index:

Variable Index:

Type Definition Details:

◆ integer

◆ intGap_t

◆ uinteger

◆ uintGap_t

Enumeration Details:

◆ Alignment

◆ Bool

◆ Caching

◆ Case

◆ ContainerOp

◆ CreateDefaults

◆ CreateIfNotExists

◆ CurrentData

◆ Inclusion

◆ Initialization

◆ Phase

◆ Propagation

◆ Reach

◆ Recursive

◆ ReportExceptions

◆ Responsibility

◆ Safeness

◆ Side

◆ SortOrder

◆ SourceData

◆ Switch

◆ Timezone

◆ Timing

◆ ValueReference

◆ Whitespaces

Function Details:

◆ BitCount()

◆ bitsofval()

◆ CLZ()

◆ CLZ0()

◆ CTZ()

◆ CTZ0()

◆ DbgSimpleALibMsg() [1/2]

◆ DbgSimpleALibMsg() [2/2]

◆ debugReportPlugin()

◆ Destruct()

◆ IsNotNull()

◆ IsNull()

◆ Log2OfSize()

◆ LowerBits() [1/2]

◆ LowerBits() [2/2]

◆ LowerMask() [1/2]

◆ LowerMask() [2/2]

◆ MSB()

◆ MSB0()

◆ SafeCast()

◆ SetNull()

◆ UpperMask() [1/2]

◆ UpperMask() [2/2]

Variable Details:

◆ DBG_CRITICAL_SECTION_YIELD_OR_SLEEP_TIME_IN_NS

◆ DBG_SIMPLE_ALIB_MSG_PLUGIN