Name |
Description |
AlignedBuffer
|
An instance of this union is a block of raw memory of specified SIZE and ALIGNMENT. A AlignedBuffer object does not manage the construction or destruction of any other objects. SIZE is rounded up to the nearest multiple of ALIGNMENT. An instantiation of this union template will not compile unless ALIGNMENT is a power of two not larger than AlignmentUtil::BSLS_MAX_ALIGNMENT. |
AlignedBuffer_Data
|
This private implementation type provides a public char array data member d_buffer whose length is the specifed (template parameter) SIZE and which is aligned according to the specified (template parameter) ALIGNMENT. |
Alignment
|
This struct provides a namespace for enumerating the set of strategies for aligning arbitrary blocks of memory. |
AlignmentFromType
|
This struct computes (at compile time) a constant integral VALUE that specifies the required alignment for TYPE objects. Also provided is a typedef, Type, that is an alias for a primitive type that has the same alignment requirements as TYPE. |
AlignmentImpCalc
|
This struct provides an enumerator VALUE that is initialized to the required alignment for the specified TYPE. |
AlignmentImpMatch
|
Namespace for a set of overloaded match functions, as defined by the macro BSLS_ALIGNMENTIMP_MATCH_FUNC. |
AlignmentImpPriorityToType
|
Specializations of this struct provide a primitive type (as a Type typedef) that corresponds to the specified PRIORITY level. |
AlignmentImpTag
|
This struct defines a unique type having the specified compile‐time SIZE. |
AlignmentImp_Priority
|
This struct provides a unique type that can be used as a trailing function parameter for overloaded functions having otherwise identical parameters. The highest‐priority overloaded function can be selected by calling it with a high‐priority argument. Note that "highest priority" means the largest VALUE in this case. |
AlignmentToType
|
This struct provides a typedef, Type, that aliases a type having the specified ALIGNMENT requirement. |
AlignmentUtil
|
This struct provides a namespace for a suite of compile‐time constants, types, and pure procedures that provide platform‐dependent alignment information. |
Assert
|
This "utility" class maintains a pointer containing the address of the current assertion‐failure handler function (of type Assert::ViolationHandler) and provides methods to administer this function pointer. The invokeHandler method calls the currently‐installed failure handler. This class also provides a suite of standard failure‐handler functions that are suitable to be installed as the current Assert::ViolationHandler function. Note that clients are free to install any of these ("off‐the‐shelf") handlers, or to provide their own ("custom") assertion‐failure handler functions when using this facility. Also note that assertion‐failure handler functions must not return (i.e., they must abort, exit, terminate, throw, or hang). |
AssertFailureHandlerGuard
|
An object of this class saves the current assert handler and installs the one specified on construction. On destruction, the original assert handler is restored. Note that two objects of this class cannot be safely used concurrently from two separate threads (but may of course appear sequentially, including in nested blocks and function invocations within a single thread). Note that the behavior of objects of this class is unaffected by the (static) Assert::lockAssertAdministration method (i.e., the temporary replacement will occur, regardless of whether that method has been invoked.) |
AssertImpUtil
|
This "implementation utility" struct provides static functions with shared functionality that is made use of by both bsls_assert and bsls_review. |
AssertImpUtil_UseContractsNo
|
Tag type indicating language‐level contracts are not enabled. |
AssertTest
|
This utility struct provides a suite of methods designed for use in conjunction with preprocessor macros during the negative testing of defensive checks using the facilities provided by the bsls_assert component. Unlike usual BDE functionality methods in this struct provide wide contracts because they need to function without assertion failures during testing, under unforeseen circumstances. |
AssertTestException
|
This class is an implementation detail of the bsls testing framework and should not be used directly in user code. It implements an immutable mechanism to communicate information about the context of an assertion that fails to a test‐case handler. |
AssertTestException_String
|
This non‐assignable class owns a null‐terminated string, provides no accessors to manipulate that string, and allocates a new copy of that string when copied. |
AssertTestHandlerGuard
|
This class provides a guard that will install and uninstall the negative testing assertion handler, AssertTest::failTestDriver, within the protected scope, as well as a corresponding review handler, AssertTest::failTestDriverByReview. |
AssertViolation
|
This class is an unconstrained in‐core value‐semantic class that characterizes the details of a assert failure that has occurred. |
AtomicBool
|
This class implements an atomic boolean, which supports common boolean operations in a way that is guaranteed to be atomic. Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i.e., Acquire, Release, AcqRel or Relaxed). |
AtomicInt
|
This class implements an atomic integer, which supports common integer operations in a way that is guaranteed to be atomic. Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i.e., Acquire, Release, AcqRel or Relaxed). |
AtomicInt64
|
This class is implements an atomic 64‐bit integer, which supports common integer operations in a way that is guaranteed to be atomic. Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i.e., Acquire, Release, AcqRel or Relaxed). |
AtomicOperations
|
AtomicOperations provides a namespace for a suite of atomic operations on the following types as defined by the AtomicTypes typedef: integer ‐ AtomicTypes::Int, 64bit integer ‐ AtomicTypes::Int64, pointer ‐ AtomicTypes::Pointer.
|
AtomicOperations_ALL_ALL_ClangIntrinsics
|
Platform‐specific atomic operations using clang __c11_atomic_* intrinsics. |
AtomicOperations_Default32
|
This class provides default implementations of non‐essential atomic operations for the 32‐bit integer, 64‐bit integer, the 32‐bit unsigned integer, 64‐bit unsigned integer and 32‐bit pointer type for a generic 32‐bit platform. |
AtomicOperations_Default64
|
This class provides default implementations of non‐essential atomic operations for the 32‐bit integer, 64‐bit integer, the 32‐bit unsigned integer, 64‐bit unsigned integer and 64‐bit pointer type for a generic 64‐bit platform. |
AtomicOperations_DefaultInt
|
This class provides default implementations of non‐essential atomic operations for the 32‐bit integer type independent on any specific platform. It also provides prototypes for the atomic operations for the 32‐bit integer type that have to be implemented separately for each specific platform. These platform‐independent and platform‐specific atomic operations together form a full set of atomic operations for the 32‐bit integer type. |
AtomicOperations_DefaultInt64
|
This class provides default implementations of non‐essential atomic operations for the 64‐bit integer type independent on any specific platform. It also provides prototypes for the atomic operations for the 64‐bit integer type that have to be implemented separately for each specific platform. These platform‐independent and platform‐specific atomic operations together form a full set of atomic operations for the 64‐bit integer type. |
AtomicOperations_DefaultPointer32
|
This class provides default implementations of non‐essential atomic operations for the 32‐bit pointer type independent on any specific platform. It also provides prototypes for the atomic operations for the pointer type that have to be implemented separately for each specific platform. These platform‐independent and platform‐specific atomic operations combined together form a full set of atomic operations for the pointer type. |
AtomicOperations_DefaultPointer64
|
This class provides default implementations of non‐essential atomic operations for the 64‐bit pointer type independent on any specific platform. It also provides prototypes for the atomic operations for the pointer type that have to be implemented separately for each specific platform. These platform‐independent and platform‐specific atomic operations combined together form a full set of atomic operations for the pointer type. |
AtomicOperations_DefaultUint
|
This class provides default implementations of non‐essential atomic operations for the 32‐bit unsigned integer type independent on any specific platform. It also provides prototypes for the atomic operations for the 32‐bit unsigned integer type that have to be implemented separately for each specific platform. These platform‐independent and platform‐specific atomic operations together form a full set of atomic operations for the 32‐bit unsigned integer type. |
AtomicOperations_DefaultUint64
|
This class provides default implementations of non‐essential atomic operations for the 64‐bit unsigned integer type independent on any specific platform. It also provides prototypes for the atomic operations for the 64‐bit unsigned integer type that have to be implemented separately for each specific platform. These platform‐independent and platform‐specific atomic operations together form a full set of atomic operations for the 64‐bit unsigned integer type. |
AtomicOperations_X64_ALL_GCC
|
|
AtomicPointer
|
This class implements an atomic pointer to a parameterized TYPE, which supports common pointer operations in a way that is guaranteed to be atomic. Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i.e., Acquire, Release, AcqRel or Relaxed). |
AtomicUint
|
This class implements an atomic unsigned integer, which supports common unsigned integer operations in a way that is guaranteed to be atomic. Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i.e., Acquire, Release, AcqRel or Relaxed). |
AtomicUint64
|
This class is implements an atomic 64‐bit unsigned integer, which supports common unsigned integer operations in a way that is guaranteed to be atomic. Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i.e., Acquire, Release, AcqRel or Relaxed). |
Atomic_TypeTraits
|
Forward declaration of atomic type traits for implementation class IMP. |
BlockGrowth
|
This struct provides a namespace for memory block growth strategies for pools, allocators, containers, etc. |
BslExceptionUtil
|
This struct provides a namespace for static utility functions that throw standard library exceptions. |
BslLock
|
This class implements a light‐weight, portable wrapper of an OS‐level mutex to support intra‐process synchronization. The mutex implemented by this class is non‐recursive. Note that BslLock is not intended for direct use by client code; it is meant for internal use only. |
BslLockGuard
|
This class implements a guard for automatically acquiring and releasing the lock on an associated bsls::BslLock object. This mechanism follows the RAII idiom whereby the lock on the BslLock associated with a guard object is acquired upon construction and released upon destruction. |
BslLockImpl_pthread
|
This class implements a light‐weight wrapper of an OS‐level mutex to support intra‐process synchronization. The mutex implemented by this class is non‐recursive. Note that BslLockImpl_pthread is not intended for direct use by client code; it is meant for internal use only. |
BslOnce
|
This struct provides a simple data type for ensuring a block of code is executed (only) once. Note that this is defined as a struct to allow constant initialization in a global or static context using BSLS_BSLONCE_INITIALIZER. |
BslOnceGuard
|
This class provides a guard for managing a BslOnce for the purpose of executing a block of code (only) once. |
BslSourceNameParserUtil
|
This struct provides a namespace for static utility functions that parse source file names (as may be reported by the FILE macro), including Lakos‐style component source and test driver names. |
BslTestUtil
|
This class provides a namespace for utilities that are useful when writing a test driver that is not permitted to use the standard C++ iostream facilities, which is typical of test drivers in the bsl package group. |
BuildTargetExcYes
|
Tag type indicating that the build target has exceptions enabled. |
ByteOrderUtil
|
This class provides a namespace for functions used for reversing the byte order of values having integral type. |
FuzzTestHandlerGuard
|
This class provides a guard that will install and uninstall four handlers, one for assertion failure, one for review failure, one for BSLS_PRECONDITIONS_BEGIN, and one for BSLS_PRECONDITIONS_END, within its protected scope. |
FuzzTestPreconditionException
|
This class is an implementation detail of the bsls fuzz testing framework and should not be used directly in user code. It implements an immutable mechanism to communicate to a test‐case handler information about the context of a precondition that fails. |
FuzzTestPreconditionTracker
|
This utility class is used by the preprocessor macros to appropriately handle precondition violations that occur in different levels and components. |
FuzzTest_TestUtil
|
This utility class provides sample functions to demonstrate an AssertViolation or a ReviewViolation originating from a different component to facilitate testing of bsls_fuzztest component. |
Log
|
This class serves as a namespace containing a suite of utility functions that allow low‐level code to write log messages to a configurable, globally controlled destination. |
LogSeverity
|
This struct provides a namespace for enumerating the set of logging severity levels used in the bsls logging framework (see bsls_log). See Enum in the TYPES sub‐section for details. |
NameOf
|
This class provides a means to display the type name of its template parameter TYPE. An instance of this class can be implicitly (or explicitly via the name accessor) cast to a const char * which will point to a buffer containing the description of the type. Note that all instances of a given type will refer to the same character buffer containing the name. |
NameOf_Base
|
This class provide non‐template implementation code for the NameOf template class. |
ObjectBuffer
|
An instance of this union is a raw block of memory suitable for storing an object of type TYPE. Specifically, the size and alignment of this union exactly matches that of TYPE. A TYPE object can be constructed into an ObjectBuffer using the placement new operator and can be destroyed by explicitly calling its destructor, ~TYPE(). It is the user's responsibility to perform this construction and destruction; an ObjectBuffer object does not manage the construction or destruction of any other objects. |
OutputRedirector
|
This class provides a facility for redirecting stdout and stderr to temporary files, retrieving output from the respective temporary file and comparing the output to user‐supplied character buffers. An OutputRedirector object can be in an un‐redirected state or a redirected state. If the redirector is in a redirected state, it will redirect either stdout or stderr, but not both simultaneously. An OutputRedirector object has the concept of a scratch buffer, where output captured from the process' stdout or stderr stream is stored when the OutputRedirector object is in the redirected state. Throughout this class, the term "captured output" refers to data that has been written to the stdout or stderr stream and is waiting to be loaded into the scratch buffer. Each time the load method is called, the scratch buffer is truncated, and the captured output is moved into the scratch buffer. When this is done, there is no longer any captured output. |
PerformanceHint
|
This struct provides a namespace for a suite of functions that give performance hints to the compiler or hardware. |
Platform
|
Namespace for platform‐trait definitions. |
PlatformUtil
|
Provide a namespace for a suite of `typedef`s and pure procedures that encapsulate, platform‐dependent types and APIs. |
PointerCastUtil
|
This struct provides a namespace for a static utility function that allows casting between function and data pointers. |
PreconditionsHandler
|
This utility class maintains pointers containing the addresses of functions invoked by the BSLS_PRECONDITIONS_BEGIN and BSLS_PRECONDITIONS_END macros, and provides methods to manipulate and utilize those functions. |
ProtocolTest
|
This mechanism class template provides the implementation of protocol testing concerns via test* methods (for non‐method concerns), and via operator‐> (for method concerns). The BSLS_TESTIMP template parameter is required to be a class derived from ProtocolTestImp that provides test implementations of all protocol methods. |
ProtocolTestImp
|
This mechanism class template is a base class for a test implementation of a protocol class defined by the BSLS_PROTOCOL template parameter. Its purpose is to reduce the boilerplate test code required to verify that derived virtual methods are called. It provides markDone member functions one of which should be called from each method of the protocol class test implementation to indicate that the virtual method is correctly overridden. It also overloads operator‐> to serve as a proxy to BSLS_PROTOCOL and detect when BSLS_PROTOCOL methods are called. |
ProtocolTest_AsBigAsT
|
This auxiliary structure has a size no less than the size of (template parameter) T. |
ProtocolTest_Dtor
|
This class template is a helper protocol‐test implementation class that tests that a protocol destructor is declared virtual, which it does by calling the markDone function from its destructor. The destructor will be executed if the protocol's destructor is declared virtual and not executed otherwise. Note that the BSLS_TESTIMP template parameter is required to be a type derived from ProtocolTestImp class. |
ProtocolTest_IsAbstract
|
This class template is a compile‐time meta‐function, parameterized with type T, the output of which is value, which will be true if T is abstract and false otherwise. On some platforms, the IsAbstract test makes use of the fact that a type 'an array of objects of an abstract type' (e.g., T[1]) cannot exist. Note that it is only an approximation, because this is also true for an incomplete type. But, this approximation is good enough for the purpose of testing protocol classes. On certain other platforms, the IsAbstract test will make use of the fact that abstract types cannot be returned. This approximation also has issues, noted below, but is also good enough for the purpose of testing protocol classes. |
ProtocolTest_MethodReturnRefType
|
This class is a proxy for a return type designed to simplify testing implementations of protocol methods. ProtocolTest_MethodReturnRefType can be converted to any reference type. When an object of this class is returned from a test implementation of a protocol method, it is implicitly converted to the return type of the protocol method. |
ProtocolTest_MethodReturnType
|
This class is a proxy for a return type designed to simplify testing implementations of protocol methods. ProtocolTest_MethodReturnType can be converted to any non‐reference type (i.e., the type can be either a value or pointer type, but not a reference type). When an object of this class is returned from a test implementation of a protocol method, it is implicitly converted to the return type of the protocol method. |
ProtocolTest_Status
|
This class keeps track of the test status, which includes the status of the last test and the number of failures across all tests. |
Review
|
This "utility" class maintains a pointer containing the address of the current review‐failure handler function (of type Review::ViolationHandler) and provides methods to administer this function pointer. The invokeHandler method calls the currently‐installed failure handler. The default installed handler is the Review::failByLog function. |
ReviewFailureHandlerGuard
|
An object of this class saves the current review handler and installs the one specified on construction. On destruction, the original review handler is restored. Note that two objects of this class cannot be safely used concurrently from two separate threads (but may of course appear sequentially, including in nested blocks and function invocations within a single thread). Note that the behavior of objects of this class is unaffected by the (static) Review::lockReviewAdministration method (i.e., the temporary replacement will occur, regardless of whether that method has been invoked). |
ReviewViolation
|
This class is an unconstrained in‐core value‐semantic class that characterizes the details of a review failure that has occurred. |
SpinLock
|
A statically‐initializable synchronization primitive that "spins" (i.e., executes user instructions in a tight loop) rather than blocking waiting threads using system calls. The following idiom is used to initialize SpinLock variables: ` SpinLock lock = BSLS_SPINLOCK_UNLOCKED; ` A class member d_lock of type SpinLock may be initialized using the following idiom: ` , d_lock(SpinLock::s_unlocked) ` |
SpinLockGuard
|
This type implements a scoped guard for SpinLock. |
SpinLock_MemberInitializer
|
This component‐private class is an empty type to work around legacy initialization syntax. The only object of this type should be Spinlock::s_unlocked, which should only ever be used to initialize member variables of type SpinLock. |
StackAddressUtil
|
This struct provides a namespace for the function to obtain return addresses from the stack. |
Stopwatch
|
The class provides an accumulator for the system, user, and wall times of the current process. A stopwatch can be in either the STOPPED (initial) state or the RUNNING state. It potentially tracks three values: the accumulated system time, the accumulated user time, and the accumulated wall time (all in seconds and all initially set to zero). Whether or not system and user times are accumulated is conditional on how the stopwatch is started (see the start method). While in the RUNNING state, a stopwatch accumulates the above values and it retains the values if put into the STOPPED state (unless reset is called). The accumulated times can be accessed at any time and in either state (RUNNING or STOPPED). |
SystemClockType
|
This struct provides a namespace for enumerating the set of system clock type for use in distinguishing which system clock to use for measuring time. See Enum in the TYPES sub‐section for details. |
SystemTime
|
This struct provides a namespace for system‐time‐retrieval functions. |
TimeInterval
|
Each instance of this value‐semantic type represents a time interval with nanosecond resolution. In the "canonical representation" of a time interval, the seconds field may have any 64‐bit signed integer value, with the nanoseconds field limited to the range [ ‐999,999,999..999,999,999 ], and with the additional constraint that the two fields are either both non‐negative or both non‐positive. |
TimeInterval_DurationTraits
|
Trait metafunction that determines whether the std::chrono::duration<REP, PERIOD> object can be converted to bsls::TimeInterval either implicitly or explicitly. |
TimeInterval_IsDuration
|
Template metafunction to determine if the specified TYPE is a std::chrono::duration. |
TimeInterval_RepTraits
|
Trait metafunction that determines whether the specified REP type is considered a floating point type. |
TimeUtil
|
This struct provides a namespace for a set of platform‐neutral pure procedures to access real‐time system clock functionality. High‐resolution time functions intended for interval‐timing return an interval in nanoseconds (1 nsec = 1E‐9 sec) as a platform‐independent 64‐bit integer. |
Types
|
Provide a namespace for a suite of `typedef`s that encapsulate platform‐dependent types. |
UnspecifiedBool
|
This class provides a member, d_member, whose pointer‐to‐member may be used as an "unspecified boolean type" for implicit conversion operators. |
Util
|
This struct provides a namespace for essential low‐level functions for implementing portable generic facilities such as the C++ standard library. |
Util_AssertNotLvalue
|
Metafunction that provides a dummy type when TYPE is not an lvalue. |
Util_Identity
|
This class template provides an easy way to alias a function pointer type when used as the return type of a function. The syntax for a function returning a function pointer is otherwise quite obscure, and difficult to read. As we want to return function pointers taking parameters and returning a result specified by template parameters below, it is not possible to define a simple typedef to the function type outside the function template itself. |
Util_RemoveReference
|
Metafunction providing the referenced type of the specified TYPE. |