[#BloombergLP-bsls]
= xref:BloombergLP.adoc[BloombergLP]::bsls
:relfileprefix: ../
:mrdocs:

Namespace for platform‐trait definitions.

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bsls/AlignedBuffer.adoc[`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`.
| xref:BloombergLP/bsls/AlignedBuffer_Data.adoc[`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`.
| xref:BloombergLP/bsls/Alignment.adoc[`Alignment`] 
| This `struct` provides a namespace for enumerating the set of strategies for aligning arbitrary blocks of memory.
| xref:BloombergLP/bsls/AlignmentFromType.adoc[`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`.
| xref:BloombergLP/bsls/AlignmentImpCalc-098.adoc[`AlignmentImpCalc`] 
| This `struct` provides an enumerator `VALUE` that is initialized to the required alignment for the specified `TYPE`.
| xref:BloombergLP/bsls/AlignmentImpMatch.adoc[`AlignmentImpMatch`] 
| Namespace for a set of overloaded `match` functions, as defined by the macro `BSLS_ALIGNMENTIMP_MATCH_FUNC`.
| xref:BloombergLP/bsls/AlignmentImpPriorityToType-059.adoc[`AlignmentImpPriorityToType`] 
| Specializations of this `struct` provide a primitive type (as a `Type` `typedef`) that corresponds to the specified `PRIORITY` level.
| xref:BloombergLP/bsls/AlignmentImpTag.adoc[`AlignmentImpTag`] 
| This `struct` defines a unique type having the specified compile‐time `SIZE`.
| xref:BloombergLP/bsls/AlignmentImp_Priority-0e.adoc[`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.
| xref:BloombergLP/bsls/AlignmentToType-0c.adoc[`AlignmentToType`] 
| This `struct` provides a `typedef`, `Type`, that aliases a type having the specified `ALIGNMENT` requirement.
| xref:BloombergLP/bsls/AlignmentUtil.adoc[`AlignmentUtil`] 
| This `struct` provides a namespace for a suite of compile‐time constants, types, and pure procedures that provide platform‐dependent alignment information.
| xref:BloombergLP/bsls/Assert.adoc[`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).
| xref:BloombergLP/bsls/AssertFailureHandlerGuard.adoc[`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.)
| xref:BloombergLP/bsls/AssertImpUtil.adoc[`AssertImpUtil`] 
| This "implementation utility" `struct` provides static functions with shared functionality that is made use of by both `bsls_assert` and `bsls_review`.
| xref:BloombergLP/bsls/AssertImpUtil_UseContractsNo.adoc[`AssertImpUtil_UseContractsNo`] 
| Tag type indicating language‐level contracts are not enabled.
| xref:BloombergLP/bsls/AssertTest.adoc[`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.
| xref:BloombergLP/bsls/AssertTestException.adoc[`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.
| xref:BloombergLP/bsls/AssertTestException_String.adoc[`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.
| xref:BloombergLP/bsls/AssertTestHandlerGuard.adoc[`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`.
| xref:BloombergLP/bsls/AssertViolation.adoc[`AssertViolation`] 
| This class is an unconstrained _in‐core_ value‐semantic class that characterizes the details of a assert failure that has occurred.
| xref:BloombergLP/bsls/AtomicBool.adoc[`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).
| xref:BloombergLP/bsls/AtomicInt.adoc[`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).
| xref:BloombergLP/bsls/AtomicInt64.adoc[`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).
| xref:BloombergLP/bsls/AtomicOperations.adoc[`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`.
| xref:BloombergLP/bsls/AtomicOperations_ALL_ALL_ClangIntrinsics.adoc[`AtomicOperations_ALL_ALL_ClangIntrinsics`] 
| Platform‐specific atomic operations using clang `__c11_atomic_*` intrinsics.
| xref:BloombergLP/bsls/AtomicOperations_Default32.adoc[`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.
| xref:BloombergLP/bsls/AtomicOperations_Default64-0b.adoc[`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.
| xref:BloombergLP/bsls/AtomicOperations_DefaultInt-08.adoc[`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.
| xref:BloombergLP/bsls/AtomicOperations_DefaultInt64-0a.adoc[`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.
| xref:BloombergLP/bsls/AtomicOperations_DefaultPointer32.adoc[`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.
| xref:BloombergLP/bsls/AtomicOperations_DefaultPointer64-061.adoc[`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.
| xref:BloombergLP/bsls/AtomicOperations_DefaultUint-0d7.adoc[`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.
| xref:BloombergLP/bsls/AtomicOperations_DefaultUint64-00.adoc[`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.
| xref:BloombergLP/bsls/AtomicOperations_X64_ALL_GCC.adoc[`AtomicOperations_X64_ALL_GCC`] 
| 
| xref:BloombergLP/bsls/AtomicPointer.adoc[`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).
| xref:BloombergLP/bsls/AtomicUint.adoc[`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).
| xref:BloombergLP/bsls/AtomicUint64.adoc[`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).
| xref:BloombergLP/bsls/Atomic_TypeTraits-03.adoc[`Atomic_TypeTraits`] 
| Forward declaration of atomic type traits for implementation class `IMP`.
| xref:BloombergLP/bsls/BlockGrowth.adoc[`BlockGrowth`] 
| This struct provides a namespace for memory block growth strategies for pools, allocators, containers, etc.
| xref:BloombergLP/bsls/BslExceptionUtil.adoc[`BslExceptionUtil`] 
| This `struct` provides a namespace for `static` utility functions that throw standard library exceptions.
| xref:BloombergLP/bsls/BslLock.adoc[`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.
| xref:BloombergLP/bsls/BslLockGuard.adoc[`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.
| xref:BloombergLP/bsls/BslLockImpl_pthread.adoc[`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.
| xref:BloombergLP/bsls/BslOnce.adoc[`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`.
| xref:BloombergLP/bsls/BslOnceGuard.adoc[`BslOnceGuard`] 
| This class provides a guard for managing a `BslOnce` for the purpose of executing a block of code (only) once.
| xref:BloombergLP/bsls/BslSourceNameParserUtil.adoc[`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.
| xref:BloombergLP/bsls/BslTestUtil.adoc[`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.
| xref:BloombergLP/bsls/BuildTargetExcYes.adoc[`BuildTargetExcYes`] 
| Tag type indicating that the build target has exceptions enabled.
| xref:BloombergLP/bsls/ByteOrderUtil.adoc[`ByteOrderUtil`] 
| This `class` provides a namespace for functions used for reversing the byte order of values having integral type.
| xref:BloombergLP/bsls/FuzzTestHandlerGuard.adoc[`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.
| xref:BloombergLP/bsls/FuzzTestPreconditionException.adoc[`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.
| xref:BloombergLP/bsls/FuzzTestPreconditionTracker.adoc[`FuzzTestPreconditionTracker`] 
| This utility class is used by the preprocessor macros to appropriately handle precondition violations that occur in different levels and components.
| xref:BloombergLP/bsls/FuzzTest_TestUtil.adoc[`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.
| xref:BloombergLP/bsls/Log.adoc[`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.
| xref:BloombergLP/bsls/LogSeverity.adoc[`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.
| xref:BloombergLP/bsls/NameOf.adoc[`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.
| xref:BloombergLP/bsls/NameOf_Base.adoc[`NameOf_Base`] 
| This `class` provide non‐template implementation code for the `NameOf` template class.
| xref:BloombergLP/bsls/ObjectBuffer.adoc[`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.
| xref:BloombergLP/bsls/OutputRedirector.adoc[`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.
| xref:BloombergLP/bsls/PerformanceHint.adoc[`PerformanceHint`] 
| This `struct` provides a namespace for a suite of functions that give performance hints to the compiler or hardware.
| xref:BloombergLP/bsls/Platform.adoc[`Platform`] 
| Namespace for platform‐trait definitions.
| xref:BloombergLP/bsls/PlatformUtil.adoc[`PlatformUtil`] 
| Provide a namespace for a suite of `typedef`s and pure procedures that encapsulate, platform‐dependent types and APIs.
| xref:BloombergLP/bsls/PointerCastUtil.adoc[`PointerCastUtil`] 
| This `struct` provides a namespace for a `static` utility function that allows casting between function and data pointers.
| xref:BloombergLP/bsls/PreconditionsHandler.adoc[`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.
| xref:BloombergLP/bsls/ProtocolTest.adoc[`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.
| xref:BloombergLP/bsls/ProtocolTestImp.adoc[`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.
| xref:BloombergLP/bsls/ProtocolTest_AsBigAsT.adoc[`ProtocolTest_AsBigAsT`] 
| This auxiliary structure has a size no less than the size of (template parameter) `T`.
| xref:BloombergLP/bsls/ProtocolTest_Dtor.adoc[`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.
| xref:BloombergLP/bsls/ProtocolTest_IsAbstract.adoc[`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.
| xref:BloombergLP/bsls/ProtocolTest_MethodReturnRefType.adoc[`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.
| xref:BloombergLP/bsls/ProtocolTest_MethodReturnType.adoc[`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.
| xref:BloombergLP/bsls/ProtocolTest_Status.adoc[`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.
| xref:BloombergLP/bsls/Review.adoc[`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.
| xref:BloombergLP/bsls/ReviewFailureHandlerGuard.adoc[`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).
| xref:BloombergLP/bsls/ReviewViolation.adoc[`ReviewViolation`] 
| This class is an unconstrained _in‐core_ value‐semantic class that characterizes the details of a review failure that has occurred.
| xref:BloombergLP/bsls/SpinLock.adoc[`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) `
| xref:BloombergLP/bsls/SpinLockGuard.adoc[`SpinLockGuard`] 
| This type implements a scoped guard for `SpinLock`.
| xref:BloombergLP/bsls/SpinLock_MemberInitializer.adoc[`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`.
| xref:BloombergLP/bsls/StackAddressUtil.adoc[`StackAddressUtil`] 
| This struct provides a namespace for the function to obtain return addresses from the stack.
| xref:BloombergLP/bsls/Stopwatch.adoc[`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).
| xref:BloombergLP/bsls/SystemClockType.adoc[`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.
| xref:BloombergLP/bsls/SystemTime.adoc[`SystemTime`] 
| This `struct` provides a namespace for system‐time‐retrieval functions.
| xref:BloombergLP/bsls/TimeInterval.adoc[`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.
| xref:BloombergLP/bsls/TimeInterval_DurationTraits.adoc[`TimeInterval_DurationTraits`] 
| Trait metafunction that determines whether the `std::chrono::duration<REP, PERIOD>` object can be converted to `bsls::TimeInterval` either implicitly or explicitly.
| xref:BloombergLP/bsls/TimeInterval_IsDuration-032.adoc[`TimeInterval_IsDuration`] 
| Template metafunction to determine if the specified `TYPE` is a `std::chrono::duration`.
| xref:BloombergLP/bsls/TimeInterval_RepTraits.adoc[`TimeInterval_RepTraits`] 
| Trait metafunction that determines whether the specified `REP` type is considered a floating point type.
| xref:BloombergLP/bsls/TimeUtil.adoc[`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.
| xref:BloombergLP/bsls/Types.adoc[`Types`] 
| Provide a namespace for a suite of `typedef`s that encapsulate platform‐dependent types.
| xref:BloombergLP/bsls/UnspecifiedBool-03.adoc[`UnspecifiedBool`] 
| This class provides a member, `d_member`, whose pointer‐to‐member may be used as an "unspecified boolean type" for implicit conversion operators.
| xref:BloombergLP/bsls/Util.adoc[`Util`] 
| This `struct` provides a namespace for essential low‐level functions for implementing portable generic facilities such as the C++ standard library.
| xref:BloombergLP/bsls/Util_AssertNotLvalue-04.adoc[`Util_AssertNotLvalue`] 
| Metafunction that provides a dummy `type` when `TYPE` is not an lvalue.
| xref:BloombergLP/bsls/Util_Identity.adoc[`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.
| xref:BloombergLP/bsls/Util_RemoveReference-0b.adoc[`Util_RemoveReference`] 
| Metafunction providing the referenced type of the specified `TYPE`.
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bsls/AssertImpUtil_UseContracts.adoc[`AssertImpUtil_UseContracts`] 
| Alias selecting the contracts tag type for the current build.
| xref:BloombergLP/bsls/BuildTargetExc.adoc[`BuildTargetExc`] 
| Tag type indicating that the build target has exceptions enabled.
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bsls/debugprint-0d3.adoc[`debugprint`] 
| `debugprint` overloads
| xref:BloombergLP/bsls/nameOfType.adoc[`nameOfType`] 
| Return the name of the type of the object passed to this function.
| xref:BloombergLP/bsls/operator_h.adoc[`operator""_h`] 
| This user defined literal operator converts the specified `hours` value to the respective `TimeInterval` value. The behavior is undefined unless the specified number of hours can be converted to valid `TimeInterval` object. (See the "User‐Defined Literals" section in the component‐level documentation.)
| xref:BloombergLP/bsls/operator_min.adoc[`operator""_min`] 
| This user defined literal operator converts the specified `minutes` value to the respective `TimeInterval` value. The behavior is undefined unless the specified number of minutes can be converted to valid `TimeInterval` object. (See the "User‐Defined Literals" section in the component‐level documentation.)
| xref:BloombergLP/bsls/operator_ms.adoc[`operator""_ms`] 
| This user defined literal operator converts the specified `milliseconds` value to the respective `TimeInterval` value. (See the "User‐Defined Literals" section in the component‐level documentation.)
| xref:BloombergLP/bsls/operator_ns.adoc[`operator""_ns`] 
| This user defined literal operator converts the specified `nanoseconds` value to the respective `TimeInterval` value. (See the "User‐Defined Literals" section in the component‐level documentation.)
| xref:BloombergLP/bsls/operator_s.adoc[`operator""_s`] 
| This user defined literal operator converts the specified `seconds` value to the respective `TimeInterval` value. The behavior is undefined unless the specified number of seconds can be converted to valid `TimeInterval` object. (See the "User‐Defined Literals" section in the component‐level documentation.)
| xref:BloombergLP/bsls/operator_us.adoc[`operator""_us`] 
| This user defined literal operator converts the specified `microseconds` value to the respective `TimeInterval` value. (See the "User‐Defined Literals" section in the component‐level documentation.)
| xref:BloombergLP/bsls/operator_plus-08.adoc[`operator+`] 
| Addition operators
| xref:BloombergLP/bsls/operator_minus-005.adoc[`operator‐`] 
| Unary minus operators
| xref:BloombergLP/bsls/operator_lshift.adoc[`operator<<`] 
| Write the value of the specified `timeInterval` to the specified output `stream` in a single‐line format, and return a reference providing modifiable access to `stream`. If `stream` is not valid on entry, this operation has no effect. Note that this human‐readable format is not fully specified and can change without notice. Also note that this method has the same behavior as `object.print(stream, 0, ‐1)`.
| xref:BloombergLP/bsls/operator_eq-07.adoc[`operator==`] 
| Equality operators
| xref:BloombergLP/bsls/operator_not_eq-0a.adoc[`operator!=`] 
| Inequality operators
| xref:BloombergLP/bsls/operator_lt-05.adoc[`operator<`] 
| Less‐than operators
| xref:BloombergLP/bsls/operator_le-09.adoc[`operator<=`] 
| Less‐than‐or‐equal operators
| xref:BloombergLP/bsls/operator_gt-08.adoc[`operator>`] 
| Greater‐than operators
| xref:BloombergLP/bsls/operator_ge-041.adoc[`operator>=`] 
| Greater‐than‐or‐equal operators
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#