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

Namespace for platform&hyphen;trait definitions&period;

== 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`&period; A `AlignedBuffer` object does not manage the construction or destruction of any other objects&period; `SIZE` is rounded up to the nearest multiple of `ALIGNMENT`&period; An instantiation of this union template will not compile unless `ALIGNMENT` is a power of two not larger than `AlignmentUtil&colon;&colon;BSLS&lowbar;MAX&lowbar;ALIGNMENT`&period;
| xref:BloombergLP/bsls/AlignedBuffer_Data.adoc[`AlignedBuffer&lowbar;Data`] 
| This _private_ implementation type provides a public `char` array data member `d&lowbar;buffer` whose length is the specifed (template parameter) `SIZE` and which is aligned according to the specified (template parameter) `ALIGNMENT`&period;
| xref:BloombergLP/bsls/Alignment.adoc[`Alignment`] 
| This `struct` provides a namespace for enumerating the set of strategies for aligning arbitrary blocks of memory&period;
| xref:BloombergLP/bsls/AlignmentFromType.adoc[`AlignmentFromType`] 
| This `struct` computes (at compile time) a constant integral `VALUE` that specifies the required alignment for `TYPE` objects&period; Also provided is a `typedef`, `Type`, that is an alias for a primitive type that has the same alignment requirements as `TYPE`&period;
| xref:BloombergLP/bsls/AlignmentImpCalc-098.adoc[`AlignmentImpCalc`] 
| This `struct` provides an enumerator `VALUE` that is initialized to the required alignment for the specified `TYPE`&period;
| xref:BloombergLP/bsls/AlignmentImpMatch.adoc[`AlignmentImpMatch`] 
| Namespace for a set of overloaded `match` functions, as defined by the macro `BSLS&lowbar;ALIGNMENTIMP&lowbar;MATCH&lowbar;FUNC`&period;
| 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&period;
| xref:BloombergLP/bsls/AlignmentImpTag.adoc[`AlignmentImpTag`] 
| This `struct` defines a unique type having the specified compile&hyphen;time `SIZE`&period;
| xref:BloombergLP/bsls/AlignmentImp_Priority-0e.adoc[`AlignmentImp&lowbar;Priority`] 
| This `struct` provides a unique type that can be used as a trailing function parameter for overloaded functions having otherwise identical parameters&period; The highest&hyphen;priority overloaded function can be selected by calling it with a high&hyphen;priority argument&period; Note that &quot;highest priority&quot; means the largest `VALUE` in this case&period;
| xref:BloombergLP/bsls/AlignmentToType-0c.adoc[`AlignmentToType`] 
| This `struct` provides a `typedef`, `Type`, that aliases a type having the specified `ALIGNMENT` requirement&period;
| xref:BloombergLP/bsls/AlignmentUtil.adoc[`AlignmentUtil`] 
| This `struct` provides a namespace for a suite of compile&hyphen;time constants, types, and pure procedures that provide platform&hyphen;dependent alignment information&period;
| xref:BloombergLP/bsls/Assert.adoc[`Assert`] 
| This &quot;utility&quot; class maintains a pointer containing the address of the current assertion&hyphen;failure handler function (of type `Assert&colon;&colon;ViolationHandler`) and provides methods to administer this function pointer&period; The `invokeHandler` method calls the currently&hyphen;installed failure handler&period; This class also provides a suite of standard failure&hyphen;handler functions that are suitable to be installed as the current `Assert&colon;&colon;ViolationHandler` function&period; Note that clients are free to install any of these (&quot;off&hyphen;the&hyphen;shelf&quot;) handlers, or to provide their own (&quot;custom&quot;) assertion&hyphen;failure handler functions when using this facility&period; Also note that assertion&hyphen;failure handler functions must not return (i&period;e&period;, they must `abort`, `exit`, `terminate`, `throw`, or hang)&period;
| xref:BloombergLP/bsls/AssertFailureHandlerGuard.adoc[`AssertFailureHandlerGuard`] 
| An object of this class saves the current assert handler and installs the one specified on construction&period; On destruction, the original assert handler is restored&period; 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)&period; Note that the behavior of objects of this class is unaffected by the (`static`) `Assert&colon;&colon;lockAssertAdministration` method (i&period;e&period;, the temporary replacement will occur, regardless of whether that method has been invoked&period;)
| xref:BloombergLP/bsls/AssertImpUtil.adoc[`AssertImpUtil`] 
| This &quot;implementation utility&quot; `struct` provides static functions with shared functionality that is made use of by both `bsls&lowbar;assert` and `bsls&lowbar;review`&period;
| xref:BloombergLP/bsls/AssertImpUtil_UseContractsNo.adoc[`AssertImpUtil&lowbar;UseContractsNo`] 
| Tag type indicating language&hyphen;level contracts are not enabled&period;
| 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&lowbar;assert` component&period; Unlike usual BDE functionality methods in this `struct` provide wide contracts because they need to function without assertion failures during testing, under unforeseen circumstances&period;
| 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&period; It implements an immutable mechanism to communicate information about the context of an assertion that fails to a test&hyphen;case handler&period;
| xref:BloombergLP/bsls/AssertTestException_String.adoc[`AssertTestException&lowbar;String`] 
| This non&hyphen;assignable class owns a null&hyphen;terminated string, provides no accessors to manipulate that string, and allocates a new copy of that string when copied&period;
| xref:BloombergLP/bsls/AssertTestHandlerGuard.adoc[`AssertTestHandlerGuard`] 
| This class provides a guard that will install and uninstall the negative testing assertion handler, `AssertTest&colon;&colon;failTestDriver`, within the protected scope, as well as a corresponding review handler, `AssertTest&colon;&colon;failTestDriverByReview`&period;
| xref:BloombergLP/bsls/AssertViolation.adoc[`AssertViolation`] 
| This class is an unconstrained _in&hyphen;core_ value&hyphen;semantic class that characterizes the details of a assert failure that has occurred&period;
| 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&period; Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i&period;e&period;, Acquire, Release, AcqRel or Relaxed)&period;
| 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&period; Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i&period;e&period;, Acquire, Release, AcqRel or Relaxed)&period;
| xref:BloombergLP/bsls/AtomicInt64.adoc[`AtomicInt64`] 
| This class is implements an atomic 64&hyphen;bit integer, which supports common integer operations in a way that is guaranteed to be atomic&period; Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i&period;e&period;, Acquire, Release, AcqRel or Relaxed)&period;
| 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&colon; integer &hyphen; `AtomicTypes&colon;&colon;Int`, 64bit integer &hyphen; `AtomicTypes&colon;&colon;Int64`, pointer &hyphen; `AtomicTypes&colon;&colon;Pointer`&period;
| xref:BloombergLP/bsls/AtomicOperations_ALL_ALL_ClangIntrinsics.adoc[`AtomicOperations&lowbar;ALL&lowbar;ALL&lowbar;ClangIntrinsics`] 
| Platform&hyphen;specific atomic operations using clang `&lowbar;&lowbar;c11&lowbar;atomic&lowbar;&ast;` intrinsics&period;
| xref:BloombergLP/bsls/AtomicOperations_Default32.adoc[`AtomicOperations&lowbar;Default32`] 
| This class provides default implementations of non&hyphen;essential atomic operations for the 32&hyphen;bit integer, 64&hyphen;bit integer, the 32&hyphen;bit unsigned integer, 64&hyphen;bit unsigned integer and 32&hyphen;bit pointer type for a generic 32&hyphen;bit platform&period;
| xref:BloombergLP/bsls/AtomicOperations_Default64-0b.adoc[`AtomicOperations&lowbar;Default64`] 
| This class provides default implementations of non&hyphen;essential atomic operations for the 32&hyphen;bit integer, 64&hyphen;bit integer, the 32&hyphen;bit unsigned integer, 64&hyphen;bit unsigned integer and 64&hyphen;bit pointer type for a generic 64&hyphen;bit platform&period;
| xref:BloombergLP/bsls/AtomicOperations_DefaultInt-08.adoc[`AtomicOperations&lowbar;DefaultInt`] 
| This class provides default implementations of non&hyphen;essential atomic operations for the 32&hyphen;bit integer type independent on any specific platform&period; It also provides prototypes for the atomic operations for the 32&hyphen;bit integer type that have to be implemented separately for each specific platform&period; These platform&hyphen;independent and platform&hyphen;specific atomic operations together form a full set of atomic operations for the 32&hyphen;bit integer type&period;
| xref:BloombergLP/bsls/AtomicOperations_DefaultInt64-0a.adoc[`AtomicOperations&lowbar;DefaultInt64`] 
| This class provides default implementations of non&hyphen;essential atomic operations for the 64&hyphen;bit integer type independent on any specific platform&period; It also provides prototypes for the atomic operations for the 64&hyphen;bit integer type that have to be implemented separately for each specific platform&period; These platform&hyphen;independent and platform&hyphen;specific atomic operations together form a full set of atomic operations for the 64&hyphen;bit integer type&period;
| xref:BloombergLP/bsls/AtomicOperations_DefaultPointer32.adoc[`AtomicOperations&lowbar;DefaultPointer32`] 
| This class provides default implementations of non&hyphen;essential atomic operations for the 32&hyphen;bit pointer type independent on any specific platform&period; It also provides prototypes for the atomic operations for the pointer type that have to be implemented separately for each specific platform&period; These platform&hyphen;independent and platform&hyphen;specific atomic operations combined together form a full set of atomic operations for the pointer type&period;
| xref:BloombergLP/bsls/AtomicOperations_DefaultPointer64-061.adoc[`AtomicOperations&lowbar;DefaultPointer64`] 
| This class provides default implementations of non&hyphen;essential atomic operations for the 64&hyphen;bit pointer type independent on any specific platform&period; It also provides prototypes for the atomic operations for the pointer type that have to be implemented separately for each specific platform&period; These platform&hyphen;independent and platform&hyphen;specific atomic operations combined together form a full set of atomic operations for the pointer type&period;
| xref:BloombergLP/bsls/AtomicOperations_DefaultUint-0d7.adoc[`AtomicOperations&lowbar;DefaultUint`] 
| This class provides default implementations of non&hyphen;essential atomic operations for the 32&hyphen;bit unsigned integer type independent on any specific platform&period; It also provides prototypes for the atomic operations for the 32&hyphen;bit unsigned integer type that have to be implemented separately for each specific platform&period; These platform&hyphen;independent and platform&hyphen;specific atomic operations together form a full set of atomic operations for the 32&hyphen;bit unsigned integer type&period;
| xref:BloombergLP/bsls/AtomicOperations_DefaultUint64-00.adoc[`AtomicOperations&lowbar;DefaultUint64`] 
| This class provides default implementations of non&hyphen;essential atomic operations for the 64&hyphen;bit unsigned integer type independent on any specific platform&period; It also provides prototypes for the atomic operations for the 64&hyphen;bit unsigned integer type that have to be implemented separately for each specific platform&period; These platform&hyphen;independent and platform&hyphen;specific atomic operations together form a full set of atomic operations for the 64&hyphen;bit unsigned integer type&period;
| xref:BloombergLP/bsls/AtomicOperations_X64_ALL_GCC.adoc[`AtomicOperations&lowbar;X64&lowbar;ALL&lowbar;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&period; Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i&period;e&period;, Acquire, Release, AcqRel or Relaxed)&period;
| 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&period; Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i&period;e&period;, Acquire, Release, AcqRel or Relaxed)&period;
| xref:BloombergLP/bsls/AtomicUint64.adoc[`AtomicUint64`] 
| This class is implements an atomic 64&hyphen;bit unsigned integer, which supports common unsigned integer operations in a way that is guaranteed to be atomic&period; Operations on objects of this class provide the sequential consistency memory ordering guarantee unless explicitly qualified with a less strict consistency guarantee suffix (i&period;e&period;, Acquire, Release, AcqRel or Relaxed)&period;
| xref:BloombergLP/bsls/Atomic_TypeTraits-03.adoc[`Atomic&lowbar;TypeTraits`] 
| Forward declaration of atomic type traits for implementation class `IMP`&period;
| xref:BloombergLP/bsls/BlockGrowth.adoc[`BlockGrowth`] 
| This struct provides a namespace for memory block growth strategies for pools, allocators, containers, etc&period;
| xref:BloombergLP/bsls/BslExceptionUtil.adoc[`BslExceptionUtil`] 
| This `struct` provides a namespace for `static` utility functions that throw standard library exceptions&period;
| xref:BloombergLP/bsls/BslLock.adoc[`BslLock`] 
| This `class` implements a light&hyphen;weight, portable wrapper of an OS&hyphen;level mutex to support intra&hyphen;process synchronization&period; The mutex implemented by this class is _non_&hyphen;recursive&period; Note that `BslLock` is _not_ intended for direct use by client code&semi; it is meant for internal use only&period;
| xref:BloombergLP/bsls/BslLockGuard.adoc[`BslLockGuard`] 
| This `class` implements a guard for automatically acquiring and releasing the lock on an associated `bsls&colon;&colon;BslLock` object&period; 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&period;
| xref:BloombergLP/bsls/BslLockImpl_pthread.adoc[`BslLockImpl&lowbar;pthread`] 
| This `class` implements a light&hyphen;weight wrapper of an OS&hyphen;level mutex to support intra&hyphen;process synchronization&period; The mutex implemented by this class is _non_&hyphen;recursive&period; Note that `BslLockImpl&lowbar;pthread` is _not_ intended for direct use by client code&semi; it is meant for internal use only&period;
| xref:BloombergLP/bsls/BslOnce.adoc[`BslOnce`] 
| This `struct` provides a simple data type for ensuring a block of code is executed (only) once&period; Note that this is defined as a `struct` to allow constant initialization in a global or static context using `BSLS&lowbar;BSLONCE&lowbar;INITIALIZER`&period;
| 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&period;
| 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&hyphen;style component source and test driver names&period;
| 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&plus;&plus; iostream facilities, which is typical of test drivers in the `bsl` package group&period;
| xref:BloombergLP/bsls/BuildTargetExcYes.adoc[`BuildTargetExcYes`] 
| Tag type indicating that the build target has exceptions enabled&period;
| xref:BloombergLP/bsls/ByteOrderUtil.adoc[`ByteOrderUtil`] 
| This `class` provides a namespace for functions used for reversing the byte order of values having integral type&period;
| 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&lowbar;PRECONDITIONS&lowbar;BEGIN`, and one for `BSLS&lowbar;PRECONDITIONS&lowbar;END`, within its protected scope&period;
| 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&period; It implements an immutable mechanism to communicate to a test&hyphen;case handler information about the context of a precondition that fails&period;
| 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&period;
| xref:BloombergLP/bsls/FuzzTest_TestUtil.adoc[`FuzzTest&lowbar;TestUtil`] 
| This utility class provides sample functions to demonstrate an `AssertViolation` or a `ReviewViolation` originating from a different component to facilitate testing of `bsls&lowbar;fuzztest` component&period;
| xref:BloombergLP/bsls/Log.adoc[`Log`] 
| This class serves as a namespace containing a suite of utility functions that allow low&hyphen;level code to write log messages to a configurable, globally controlled destination&period;
| 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&lowbar;log`)&period; See `Enum` in the TYPES sub&hyphen;section for details&period;
| xref:BloombergLP/bsls/NameOf.adoc[`NameOf`] 
| This `class` provides a means to display the type name of its template parameter `TYPE`&period; An instance of this `class` can be implicitly (or explicitly via the `name` accessor) cast to a `const char &ast;` which will point to a buffer containing the description of the type&period; Note that all instances of a given type will refer to the same character buffer containing the name&period;
| xref:BloombergLP/bsls/NameOf_Base.adoc[`NameOf&lowbar;Base`] 
| This `class` provide non&hyphen;template implementation code for the `NameOf` template class&period;
| 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`&period; Specifically, the size and alignment of this union exactly matches that of `TYPE`&period; A `TYPE` object can be constructed into an `ObjectBuffer` using the placement `new` operator and can be destroyed by explicitly calling its destructor, `&#126;TYPE()`&period; It is the user&apos;s responsibility to perform this construction and destruction&semi; an `ObjectBuffer` object does not manage the construction or destruction of any other objects&period;
| 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&hyphen;supplied character buffers&period; An `OutputRedirector` object can be in an un&hyphen;redirected state or a redirected state&period; If the redirector is in a redirected state, it will redirect either `stdout` or `stderr`, but not both simultaneously&period; An `OutputRedirector` object has the concept of a scratch buffer, where output captured from the process&apos; `stdout` or `stderr` stream is stored when the `OutputRedirector` object is in the redirected state&period; Throughout this class, the term &quot;captured output&quot; refers to data that has been written to the `stdout` or `stderr` stream and is waiting to be loaded into the scratch buffer&period; Each time the `load` method is called, the scratch buffer is truncated, and the captured output is moved into the scratch buffer&period; When this is done, there is no longer any captured output&period;
| 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&period;
| xref:BloombergLP/bsls/Platform.adoc[`Platform`] 
| Namespace for platform&hyphen;trait definitions&period;
| xref:BloombergLP/bsls/PlatformUtil.adoc[`PlatformUtil`] 
| Provide a namespace for a suite of `typedef`s and pure procedures that encapsulate, platform&hyphen;dependent types and APIs&period;
| xref:BloombergLP/bsls/PointerCastUtil.adoc[`PointerCastUtil`] 
| This `struct` provides a namespace for a `static` utility function that allows casting between function and data pointers&period;
| xref:BloombergLP/bsls/PreconditionsHandler.adoc[`PreconditionsHandler`] 
| This utility class maintains pointers containing the addresses of functions invoked by the `BSLS&lowbar;PRECONDITIONS&lowbar;BEGIN` and `BSLS&lowbar;PRECONDITIONS&lowbar;END` macros, and provides methods to manipulate and utilize those functions&period;
| xref:BloombergLP/bsls/ProtocolTest.adoc[`ProtocolTest`] 
| This mechanism class template provides the implementation of protocol testing concerns via `test&ast;` methods (for non&hyphen;method concerns), and via `operator&hyphen;&gt;` (for method concerns)&period; The `BSLS&lowbar;TESTIMP` template parameter is required to be a class derived from `ProtocolTestImp` that provides test implementations of all protocol methods&period;
| 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&lowbar;PROTOCOL` template parameter&period; Its purpose is to reduce the boilerplate test code required to verify that derived virtual methods are called&period; 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&period; It also overloads `operator&hyphen;&gt;` to serve as a proxy to `BSLS&lowbar;PROTOCOL` and detect when `BSLS&lowbar;PROTOCOL` methods are called&period;
| xref:BloombergLP/bsls/ProtocolTest_AsBigAsT.adoc[`ProtocolTest&lowbar;AsBigAsT`] 
| This auxiliary structure has a size no less than the size of (template parameter) `T`&period;
| xref:BloombergLP/bsls/ProtocolTest_Dtor.adoc[`ProtocolTest&lowbar;Dtor`] 
| This class template is a helper protocol&hyphen;test implementation class that tests that a protocol destructor is declared `virtual`, which it does by calling the `markDone` function from its destructor&period; The destructor will be executed if the protocol&apos;s destructor is declared `virtual` and not executed otherwise&period; Note that the `BSLS&lowbar;TESTIMP` template parameter is required to be a type derived from `ProtocolTestImp` class&period;
| xref:BloombergLP/bsls/ProtocolTest_IsAbstract.adoc[`ProtocolTest&lowbar;IsAbstract`] 
| This class template is a compile&hyphen;time meta&hyphen;function, parameterized with type `T`, the output of which is `value`, which will be `true` if `T` is abstract and `false` otherwise&period; On some platforms, the `IsAbstract` test makes use of the fact that a type &apos;an array of objects of an abstract type&apos; (e&period;g&period;, `T&lsqb;1&rsqb;`) cannot exist&period; Note that it is only an approximation, because this is also true for an incomplete type&period; But, this approximation is good enough for the purpose of testing protocol classes&period; On certain other platforms, the `IsAbstract` test will make use of the fact that abstract types cannot be returned&period; This approximation also has issues, noted below, but is also good enough for the purpose of testing protocol classes&period;
| xref:BloombergLP/bsls/ProtocolTest_MethodReturnRefType.adoc[`ProtocolTest&lowbar;MethodReturnRefType`] 
| This class is a proxy for a return type designed to simplify testing implementations of protocol methods&period; `ProtocolTest&lowbar;MethodReturnRefType` can be converted to any reference type&period; 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&period;
| xref:BloombergLP/bsls/ProtocolTest_MethodReturnType.adoc[`ProtocolTest&lowbar;MethodReturnType`] 
| This class is a proxy for a return type designed to simplify testing implementations of protocol methods&period; `ProtocolTest&lowbar;MethodReturnType` can be converted to any non&hyphen;reference type (i&period;e&period;, the type can be either a value or pointer type, but not a reference type)&period; 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&period;
| xref:BloombergLP/bsls/ProtocolTest_Status.adoc[`ProtocolTest&lowbar;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&period;
| xref:BloombergLP/bsls/Review.adoc[`Review`] 
| This &quot;utility&quot; class maintains a pointer containing the address of the current review&hyphen;failure handler function (of type `Review&colon;&colon;ViolationHandler`) and provides methods to administer this function pointer&period; The `invokeHandler` method calls the currently&hyphen;installed failure handler&period; The default installed handler is the `Review&colon;&colon;failByLog` function&period;
| xref:BloombergLP/bsls/ReviewFailureHandlerGuard.adoc[`ReviewFailureHandlerGuard`] 
| An object of this class saves the current review handler and installs the one specified on construction&period; On destruction, the original review handler is restored&period; 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)&period; Note that the behavior of objects of this class is unaffected by the (`static`) `Review&colon;&colon;lockReviewAdministration` method (i&period;e&period;, the temporary replacement will occur, regardless of whether that method has been invoked)&period;
| xref:BloombergLP/bsls/ReviewViolation.adoc[`ReviewViolation`] 
| This class is an unconstrained _in&hyphen;core_ value&hyphen;semantic class that characterizes the details of a review failure that has occurred&period;
| xref:BloombergLP/bsls/SpinLock.adoc[`SpinLock`] 
| A statically&hyphen;initializable synchronization primitive that &quot;spins&quot; (i&period;e&period;, executes user instructions in a tight loop) rather than blocking waiting threads using system calls&period; The following idiom is used to initialize `SpinLock` variables&colon; &grave; SpinLock lock &equals; BSLS&lowbar;SPINLOCK&lowbar;UNLOCKED&semi; &grave; A class member `d&lowbar;lock` of type `SpinLock` may be initialized using the following idiom&colon; &grave; , d&lowbar;lock(SpinLock&colon;&colon;s&lowbar;unlocked) &grave;
| xref:BloombergLP/bsls/SpinLockGuard.adoc[`SpinLockGuard`] 
| This type implements a scoped guard for `SpinLock`&period;
| xref:BloombergLP/bsls/SpinLock_MemberInitializer.adoc[`SpinLock&lowbar;MemberInitializer`] 
| This component&hyphen;private class is an empty type to work around legacy initialization syntax&period; The only object of this type should be `Spinlock&colon;&colon;s&lowbar;unlocked`, which should only ever be used to initialize member variables of type `SpinLock`&period;
| xref:BloombergLP/bsls/StackAddressUtil.adoc[`StackAddressUtil`] 
| This struct provides a namespace for the function to obtain return addresses from the stack&period;
| xref:BloombergLP/bsls/Stopwatch.adoc[`Stopwatch`] 
| The `class` provides an accumulator for the system, user, and wall times of the current process&period; A stopwatch can be in either the STOPPED (initial) state or the RUNNING state&period; It potentially tracks three values&colon; the accumulated system time, the accumulated user time, and the accumulated wall time (all in seconds and all initially set to zero)&period; Whether or not system and user times are accumulated is conditional on how the stopwatch is started (see the `start` method)&period; 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)&period; The accumulated times can be accessed at any time and in either state (RUNNING or STOPPED)&period;
| 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&period; See `Enum` in the TYPES sub&hyphen;section for details&period;
| xref:BloombergLP/bsls/SystemTime.adoc[`SystemTime`] 
| This `struct` provides a namespace for system&hyphen;time&hyphen;retrieval functions&period;
| xref:BloombergLP/bsls/TimeInterval.adoc[`TimeInterval`] 
| Each instance of this value&hyphen;semantic type represents a time interval with nanosecond resolution&period; In the &quot;canonical representation&quot; of a time interval, the `seconds` field may have any 64&hyphen;bit signed integer value, with the `nanoseconds` field limited to the range `&lsqb; &hyphen;999,999,999&period;&period;999,999,999 &rsqb;`, and with the additional constraint that the two fields are either both non&hyphen;negative or both non&hyphen;positive&period;
| xref:BloombergLP/bsls/TimeInterval_DurationTraits.adoc[`TimeInterval&lowbar;DurationTraits`] 
| Trait metafunction that determines whether the `std&colon;&colon;chrono&colon;&colon;duration&lt;REP, PERIOD&gt;` object can be converted to `bsls&colon;&colon;TimeInterval` either implicitly or explicitly&period;
| xref:BloombergLP/bsls/TimeInterval_IsDuration-032.adoc[`TimeInterval&lowbar;IsDuration`] 
| Template metafunction to determine if the specified `TYPE` is a `std&colon;&colon;chrono&colon;&colon;duration`&period;
| xref:BloombergLP/bsls/TimeInterval_RepTraits.adoc[`TimeInterval&lowbar;RepTraits`] 
| Trait metafunction that determines whether the specified `REP` type is considered a floating point type&period;
| xref:BloombergLP/bsls/TimeUtil.adoc[`TimeUtil`] 
| This `struct` provides a namespace for a set of platform&hyphen;neutral pure procedures to access real&hyphen;time system clock functionality&period; High&hyphen;resolution time functions intended for interval&hyphen;timing return an interval in nanoseconds (1 nsec &equals; 1E&hyphen;9 sec) as a platform&hyphen;independent 64&hyphen;bit integer&period;
| xref:BloombergLP/bsls/Types.adoc[`Types`] 
| Provide a namespace for a suite of `typedef`s that encapsulate platform&hyphen;dependent types&period;
| xref:BloombergLP/bsls/UnspecifiedBool-03.adoc[`UnspecifiedBool`] 
| This class provides a member, `d&lowbar;member`, whose pointer&hyphen;to&hyphen;member may be used as an &quot;unspecified boolean type&quot; for implicit conversion operators&period;
| xref:BloombergLP/bsls/Util.adoc[`Util`] 
| This `struct` provides a namespace for essential low&hyphen;level functions for implementing portable generic facilities such as the C&plus;&plus; standard library&period;
| xref:BloombergLP/bsls/Util_AssertNotLvalue-04.adoc[`Util&lowbar;AssertNotLvalue`] 
| Metafunction that provides a dummy `type` when `TYPE` is not an lvalue&period;
| xref:BloombergLP/bsls/Util_Identity.adoc[`Util&lowbar;Identity`] 
| This class template provides an easy way to alias a function pointer type when used as the return type of a function&period; The syntax for a function returning a function pointer is otherwise quite obscure, and difficult to read&period; 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&period;
| xref:BloombergLP/bsls/Util_RemoveReference-0b.adoc[`Util&lowbar;RemoveReference`] 
| Metafunction providing the referenced type of the specified `TYPE`&period;
|===


== Type Aliases

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


== 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&period;
| xref:BloombergLP/bsls/operator_h.adoc[`operator&quot;&quot;&lowbar;h`] 
| This user defined literal operator converts the specified `hours` value to the respective `TimeInterval` value&period; The behavior is undefined unless the specified number of hours can be converted to valid `TimeInterval` object&period; (See the &quot;User&hyphen;Defined Literals&quot; section in the component&hyphen;level documentation&period;)
| xref:BloombergLP/bsls/operator_min.adoc[`operator&quot;&quot;&lowbar;min`] 
| This user defined literal operator converts the specified `minutes` value to the respective `TimeInterval` value&period; The behavior is undefined unless the specified number of minutes can be converted to valid `TimeInterval` object&period; (See the &quot;User&hyphen;Defined Literals&quot; section in the component&hyphen;level documentation&period;)
| xref:BloombergLP/bsls/operator_ms.adoc[`operator&quot;&quot;&lowbar;ms`] 
| This user defined literal operator converts the specified `milliseconds` value to the respective `TimeInterval` value&period; (See the &quot;User&hyphen;Defined Literals&quot; section in the component&hyphen;level documentation&period;)
| xref:BloombergLP/bsls/operator_ns.adoc[`operator&quot;&quot;&lowbar;ns`] 
| This user defined literal operator converts the specified `nanoseconds` value to the respective `TimeInterval` value&period; (See the &quot;User&hyphen;Defined Literals&quot; section in the component&hyphen;level documentation&period;)
| xref:BloombergLP/bsls/operator_s.adoc[`operator&quot;&quot;&lowbar;s`] 
| This user defined literal operator converts the specified `seconds` value to the respective `TimeInterval` value&period; The behavior is undefined unless the specified number of seconds can be converted to valid `TimeInterval` object&period; (See the &quot;User&hyphen;Defined Literals&quot; section in the component&hyphen;level documentation&period;)
| xref:BloombergLP/bsls/operator_us.adoc[`operator&quot;&quot;&lowbar;us`] 
| This user defined literal operator converts the specified `microseconds` value to the respective `TimeInterval` value&period; (See the &quot;User&hyphen;Defined Literals&quot; section in the component&hyphen;level documentation&period;)
| xref:BloombergLP/bsls/operator_plus-08.adoc[`operator&plus;`] 
| Addition operators
| xref:BloombergLP/bsls/operator_minus-005.adoc[`operator&hyphen;`] 
| Unary minus operators
| xref:BloombergLP/bsls/operator_lshift.adoc[`operator&lt;&lt;`] 
| Write the value of the specified `timeInterval` to the specified output `stream` in a single&hyphen;line format, and return a reference providing modifiable access to `stream`&period; If `stream` is not valid on entry, this operation has no effect&period; Note that this human&hyphen;readable format is not fully specified and can change without notice&period; Also note that this method has the same behavior as `object&period;print(stream, 0, &hyphen;1)`&period;
| xref:BloombergLP/bsls/operator_eq-07.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:BloombergLP/bsls/operator_not_eq-0a.adoc[`operator!&equals;`] 
| Inequality operators
| xref:BloombergLP/bsls/operator_lt-05.adoc[`operator&lt;`] 
| Less&hyphen;than operators
| xref:BloombergLP/bsls/operator_le-09.adoc[`operator&lt;&equals;`] 
| Less&hyphen;than&hyphen;or&hyphen;equal operators
| xref:BloombergLP/bsls/operator_gt-08.adoc[`operator&gt;`] 
| Greater&hyphen;than operators
| xref:BloombergLP/bsls/operator_ge-041.adoc[`operator&gt;&equals;`] 
| Greater&hyphen;than&hyphen;or&hyphen;equal operators
|===



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