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

Namespace for bit&hyphen;level utility functions&period;

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlb/PrintMethods.adoc[`PrintMethods`] 
| This `namespace` contains parameterized `print` methods having the standard BDE signature for such methods&period;
|===


== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlb/AlgorithmWorkaroundUtil.adoc[`AlgorithmWorkaroundUtil`] 
| A namespace for replacement workarounds for some platform supplied faulty algorithms (particularly for the Sun Studio compiler)&period;
| xref:BloombergLP/bdlb/ArrayUtil.adoc[`ArrayUtil`] 
| This `struct` provides a namespace for a collection of function templates providing access to the length and iterators of statically sized built&hyphen;in arrays
| xref:BloombergLP/bdlb/BigEndianInt16.adoc[`BigEndianInt16`] 
| This class provides a container for an in&hyphen;core representation of a signed 16&hyphen;bit big&hyphen;endian integer&period; It supports a complete set of _value_ _semantic_ operations, including copy construction, assignment, equality comparison, `bsl&colon;&colon;ostream` printing, and BDEX serialization&period; Note that the copy constructor and copy&hyphen;assignment operator are provided by the compiler&period; Any object of this class can be converted to a `short` allowing comparison with any other object of this class&period; This class is _exception_ _neutral_ with no guarantee of rollback&colon; if an exception is thrown during the invocation of a method on a pre&hyphen;existing object, the object is left in a valid state, but its value is undefined&period; In no event is memory leaked&period; Finally, _aliasing_ (e&period;g&period;, using all or part of an object as both source and destination) is supported in all cases&period;
| xref:BloombergLP/bdlb/BigEndianInt32.adoc[`BigEndianInt32`] 
| This class provides a container for an in&hyphen;core representation of a signed 32&hyphen;bit big&hyphen;endian integer&period; It supports a complete set of _value_ _semantic_ operations, including copy construction, assignment, equality comparison, `bsl&colon;&colon;ostream` printing, and BDEX serialization&period; Note that the copy constructor and copy&hyphen;assignment operator are provided by the compiler&period; Any object of this class can be converted to an `int` allowing comparison with any other object of this class&period; This class is _exception_ _neutral_ with no guarantee of rollback&colon; if an exception is thrown during the invocation of a method on a pre&hyphen;existing object, the object is left in a valid state, but its value is undefined&period; In no event is memory leaked&period; Finally, _aliasing_ (e&period;g&period;, using all or part of an object as both source and destination) is supported in all cases&period;
| xref:BloombergLP/bdlb/BigEndianInt64.adoc[`BigEndianInt64`] 
| This class provides a container for an in&hyphen;core representation of a signed 64&hyphen;bit big&hyphen;endian integer&period; It supports a complete set of _value_ _semantic_ operations, including copy construction, assignment, equality comparison, `bsl&colon;&colon;ostream` printing, and BDEX serialization&period; Note that the copy constructor and copy&hyphen;assignment operator are provided by the compiler&period; Any object of this class can be converted to an `Int64` allowing comparison with any other object of this class&period; This class is _exception_ _neutral_ with no guarantee of rollback&colon; if an exception is thrown during the invocation of a method on a pre&hyphen;existing object, the object is left in a valid state, but its value is undefined&period; In no event is memory leaked&period; Finally, _aliasing_ (e&period;g&period;, using all or part of an object as both source and destination) is supported in all cases&period;
| xref:BloombergLP/bdlb/BigEndianUint16.adoc[`BigEndianUint16`] 
| This class provides a container for an in&hyphen;core representation of an unsigned 16&hyphen;bit big&hyphen;endian integer&period; It supports a complete set of _value_ _semantic_ operations, including copy construction, assignment, equality comparison, `bsl&colon;&colon;ostream` printing, and BDEX serialization&period; Note that the copy constructor and copy&hyphen;assignment operator are provided by the compiler&period; Any object of this class can be converted to an `unsigned short` allowing comparison with any other object of this class&period; This class is _exception_ _neutral_ with no guarantee of rollback&colon; if an exception is thrown during the invocation of a method on a pre&hyphen;existing object, the object is left in a valid state, but its value is undefined&period; In no event is memory leaked&period; Finally, _aliasing_ (e&period;g&period;, using all or part of an object as both source and destination) is supported in all cases&period;
| xref:BloombergLP/bdlb/BigEndianUint32.adoc[`BigEndianUint32`] 
| This class provides a container for an in&hyphen;core representation of an unsigned 32&hyphen;bit big&hyphen;endian integer&period; It supports a complete set of _value_ _semantic_ operations, including copy construction, assignment, equality comparison, `bsl&colon;&colon;ostream` printing, and BDEX serialization&period; Note that the copy constructor and copy&hyphen;assignment operator are provided by the compiler&period; Any object of this class can be converted to an `unsigned int` allowing comparison with any other object of this class&period; This class is _exception_ _neutral_ with no guarantee of rollback&colon; if an exception is thrown during the invocation of a method on a pre&hyphen;existing object, the object is left in a valid state, but its value is undefined&period; In no event is memory leaked&period; Finally, _aliasing_ (e&period;g&period;, using all or part of an object as both source and destination) is supported in all cases&period;
| xref:BloombergLP/bdlb/BigEndianUint64.adoc[`BigEndianUint64`] 
| This class provides a container for an in&hyphen;core representation of an unsigned 64&hyphen;bit big&hyphen;endian integer&period; It supports a complete set of _value_ _semantic_ operations, including copy construction, assignment, equality comparison, `bsl&colon;&colon;ostream` printing, and BDEX serialization&period; Note that the copy constructor and copy&hyphen;assignment operator are provided by the compiler&period; Any object of this class can be converted to a `Uint64` allowing comparison with any other object of this class&period; This class is _exception_ _neutral_ with no guarantee of rollback&colon; if an exception is thrown during the invocation of a method on a pre&hyphen;existing object, the object is left in a valid state, but its value is undefined&period; In no event is memory leaked&period; Finally, _aliasing_ (e&period;g&period;, using all or part of an object as both source and destination) is supported in all cases&period;
| xref:BloombergLP/bdlb/BitMaskUtil.adoc[`BitMaskUtil`] 
| This utility `struct` provides a namespace for a set of bit&hyphen;level, stateless functions that take one or two `int` arguments and return masks of the built&hyphen;in 32&hyphen; and 64&hyphen;bit integer types `uint32&lowbar;t` and `uint64&lowbar;t`, respectively&period;
| xref:BloombergLP/bdlb/BitStringImpUtil.adoc[`BitStringImpUtil`] 
| This `struct` provides a namespace for static functions to be used solely in the implementation of `BitStringUtil`&period; The &quot;Manipulators&quot; are intended to be provided as arguments to templates in `bdlb&lowbar;bitstringutil`, whereas the &quot;Accessors&quot; are to be called directly within that component&period;
| xref:BloombergLP/bdlb/BitStringUtil.adoc[`BitStringUtil`] 
| This `struct` provides a namespace for a suite of static functions to manipulate and access sequences of bits stored in an array of `uint64&lowbar;t` (also known as a &quot;bit string&quot;&semi; see &lcub;The &quot;Bit String&quot; Pseudo&hyphen;Type&rcub;)&period;
| xref:BloombergLP/bdlb/BitUtil.adoc[`BitUtil`] 
| This utility `struct` provides a namespace for a set of bit&hyphen;level, stateless functions that operate on the built&hyphen;in 32&hyphen; and 64&hyphen;bit unsigned integer types&period;
| xref:BloombergLP/bdlb/CStringEqualTo.adoc[`CStringEqualTo`] 
| This `struct` defines a comparison functor on null&hyphen;terminated character strings, enabling them for use as keys in the standard unordered associative containers such as `bsl&colon;&colon;unordered&lowbar;map` and `bsl&colon;&colon;unordered&lowbar;set`&period; Note that this class is an empty POD type&period;
| xref:BloombergLP/bdlb/CStringHash.adoc[`CStringHash`] 
| This `struct` defines a hash operation for null&hyphen;terminated character strings enabling them to be used as keys in the standard unordered associative containers such as `bsl&colon;&colon;unordered&lowbar;map` and `bsl&colon;&colon;unordered&lowbar;set`&period; Note that this class is an empty POD type&period;
| xref:BloombergLP/bdlb/CStringLess.adoc[`CStringLess`] 
| This `struct` defines an ordering on null&hyphen;terminated character strings, enabling them for use as keys in the standard associative containers such as `bsl&colon;&colon;map` and `bsl&colon;&colon;set`&period; Note that this class is an empty POD type&period;
| xref:BloombergLP/bdlb/CaselessStringViewEqualTo.adoc[`CaselessStringViewEqualTo`] 
| This `struct` defines a case&hyphen;insensitive equality comparison functor on string views, enabling them for use as keys in the standard unordered associative containers such as `bsl&colon;&colon;unordered&lowbar;map` and `bsl&colon;&colon;unordered&lowbar;set`&period; Note that this `class` is an empty POD type&period;
| xref:BloombergLP/bdlb/CaselessStringViewHash.adoc[`CaselessStringViewHash`] 
| This `struct` defines a hash operation for string views enabling `bsl&colon;&colon;string`s or `bsl&colon;&colon;string&lowbar;view`s to be used as keys in the standard unordered associative containers such as `bsl&colon;&colon;unordered&lowbar;map` and `bsl&colon;&colon;unordered&lowbar;set`&period; Note that this class is an empty POD type&period;
| xref:BloombergLP/bdlb/CaselessStringViewLess.adoc[`CaselessStringViewLess`] 
| This `struct` defines an ordering on string views, enabling them for use as keys in the standard associative containers such as `bsl&colon;&colon;map` and `bsl&colon;&colon;set`&period; Note that this class is an empty POD type&period;
| xref:BloombergLP/bdlb/CharType.adoc[`CharType`] 
| This `struct` provides a namespace for a suite of pure procedures operating on the fundamental type `char`&period;
| xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[`ConstNullableValueRef`] 
| This class is a wrapper for either a `bsl&colon;&colon;optional` or `NullableAllocatedValue`, and provides non&hyphen;modifiable access to the wrapped object&period;
| xref:BloombergLP/bdlb/DoubleCompareUtil.adoc[`DoubleCompareUtil`] 
| This struct provides a namespace for a suite of fuzzy (equality and relational) comparison functions on pairs of `double` values, parameterized by (optionally specified) relative and absolute tolerances&period; Note that all methods are naturally thread&hyphen;safe, and well&hyphen;behaved for all tolerance values&period;
| xref:BloombergLP/bdlb/Float.adoc[`Float`] 
| Namespace for floating&hyphen;point classification types and functions&period;
| xref:BloombergLP/bdlb/FunctionOutputIterator.adoc[`FunctionOutputIterator`] 
| Provide an output iterator that calls an object of the (template parameter) type `FUNCTION`&period; If `FUNCTION` is a functor, de&hyphen;referencing this iterator and assigning to the result (of dereferencing) will call the `operator()` of the functor with the assigned value as a parameter&period; Similarly, if `FUNCTION` if a function pointer type, assigning to the dereferenced iterator will call the function supplied at construction with the assigned value as a parameter&period;
| xref:BloombergLP/bdlb/Guid.adoc[`Guid`] 
| This class implements a value&hyphen;semantic `Guid` type&period; Each object represents an unconstrained `Guid` object, but its uniqueness is _not_ guaranteed, and this component provides no ability to generate a GUID&period;
| xref:BloombergLP/bdlb/GuidUtil.adoc[`GuidUtil`] 
| This `struct` provides a namespace for functions that create Universally Unique Identifiers per RFC 4122 (http&colon;&sol;&sol;www&period;ietf&period;org&sol;rfc&sol;rfc4122&period;txt)&period;
| xref:BloombergLP/bdlb/Guid_BslFmtFormatterImpl.adoc[`Guid&lowbar;BslFmtFormatterImpl`] 
| This component&hyphen;private class template provides the implementation of the `bsl&colon;&colon;formatter` specialization for `bdlb&colon;&colon;Guid` values&period; The specified `t&lowbar;CHAR` template parameter determines both the format&hyphen;string and the output character type&period; The behavior is undefined unless `t&lowbar;CHAR` is `char` or `wchar&lowbar;t`&period;
| xref:BloombergLP/bdlb/HasPrintMethod-03cc8.adoc[`HasPrintMethod`] 
| A class, `TYPE`, should specialize this trait to derive from `true&lowbar;type` if it has a `print` method with the following signature&colon; &grave; bsl&colon;&colon;ostream&amp; print(bsl&colon;&colon;ostream&amp; stream, int level &equals; 0, int spacesPerLevel &equals; 4) const&semi; &grave;
| xref:BloombergLP/bdlb/HashUtil.adoc[`HashUtil`] 
| This `struct` provides a namespace for hash functions&period;
| xref:BloombergLP/bdlb/IndexSpan.adoc[`IndexSpan`] 
| A constrained attribute type that represents a position and a length&period; The constraint is that the sum of the position and length attributes must be representable by the `bsl&colon;&colon;size&lowbar;t` type&period;
| xref:BloombergLP/bdlb/IndexSpanStringUtil.adoc[`IndexSpanStringUtil`] 
| This struct serves as a namespace for utility functions that operate on `IndexSpan` and string objects&period;
| xref:BloombergLP/bdlb/IndexSpanUtil.adoc[`IndexSpanUtil`] 
| This struct serves as a namespace for utility functions that operate on `IndexSpan` objects&period;
| xref:BloombergLP/bdlb/LiteralUtil.adoc[`LiteralUtil`] 
| This `struct` provides a namespace for utility routines that operate on (programming language) literals&period;
| xref:BloombergLP/bdlb/NullOutputIterator.adoc[`NullOutputIterator`] 
| Provide an output iterator that ignores the output that is provided&period; De&hyphen;referencing an iterator and assigning to the returned value has no effect&period;
| xref:BloombergLP/bdlb/NullOutputIteratorAssignmentProxy.adoc[`NullOutputIteratorAssignmentProxy`] 
| Provide an object that can appear on the left side of an assignment from `TYPE`&period; The operation AssignmentProxy() &equals; TYPE() is valid and has no effect&period;
| xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[`NullableAllocatedValue`] 
| This template class extends the set of values of its value&hyphen;semantic `TYPE` parameter to include the notion of a &quot;null&quot; value&period; If `TYPE` is fully value&hyphen;semantic, then the augmented type `NullableAllocatedValue&lt;TYPE&gt;` will be as well&period; In addition to supporting all homogeneous value&hyphen;semantic operations, conversions between comparable underlying value types is also supported&period; Two nullable objects with different underlying types compare equal if their underlying types are comparable and either (1) both objects are null or (2) the non&hyphen;null values compare equal&period; Attempts to copy construct, copy assign, or compare incompatible values types will fail to compile&period; The `NullableAllocatedValue` template can be instantiated on an incomplete type, but it cannot be instantiated on a type that overloads `operator&amp;`&period;
| xref:BloombergLP/bdlb/NullableAllocatedValue_PointerBitsPair.adoc[`NullableAllocatedValue&lowbar;PointerBitsPair`] 
| This is a component&hyphen;private class&period; Do not use&period;
| xref:BloombergLP/bdlb/NullableValue.adoc[`NullableValue`] 
| This template class extends the set of values of its value&hyphen;semantic `TYPE` parameter to include the notion of a &quot;null&quot; value&period; If `TYPE` is fully value&hyphen;semantic, then the augmented type `NullableValue&lt;TYPE&gt;` will be as well&period; In addition to supporting all homogeneous value&hyphen;semantic operations, conversions between comparable underlying value types is also supported&period; Two nullable objects with different underlying types compare equal if their underlying types are comparable and either (1) both objects are null or (2) the non&hyphen;null values compare equal&period; A null nullable object is considered ordered before any non&hyphen;null nullable object&period; Attempts to copy construct, copy assign, or compare incompatible values types will fail to compile&period; The `NullableValue` template cannot be instantiated on an incomplete type, a type that overloads unary `operator&amp;`, or `bsl&colon;&colon;nullopt&lowbar;t`&period;
| xref:BloombergLP/bdlb/NullableValueRef.adoc[`NullableValueRef`] 
| This class is a wrapper for either a `bsl&colon;&colon;optional` or `NullableAllocatedValue`, and provides modifiable access to the wrapped object&period;
| xref:BloombergLP/bdlb/NullableValue_WithAllocator.adoc[`NullableValue&lowbar;WithAllocator`] 
| Component&hyphen;private base for allocator&hyphen;aware `NullableValue` specializations&period;
| xref:BloombergLP/bdlb/NullableValue_WithoutAllocator.adoc[`NullableValue&lowbar;WithoutAllocator`] 
| Component&hyphen;private base for non&hyphen;allocator&hyphen;aware `NullableValue` specializations&period;
| xref:BloombergLP/bdlb/NumericParseUtil.adoc[`NumericParseUtil`] 
| This `struct` provides a namespace for a suite of stateless procedures that perform parsing functionality for numbers&period;
| xref:BloombergLP/bdlb/OptionalPrinter.adoc[`OptionalPrinter`] 
| Utility for printing `bsl&colon;&colon;optional` to standard output streams&period; This class has `operator&lt;&lt;` defined for it, so it can be used, for example, in `ball` logs&period;
| xref:BloombergLP/bdlb/OptionalPrinterUtil.adoc[`OptionalPrinterUtil`] 
| This utility `struct` provides a namespace for a function that creates a `bdlb&colon;&colon;OptionalPrinter` with its template argument deduced from a given instance of `bsl&colon;&colon;optional`&period;
| xref:BloombergLP/bdlb/PairUtil.adoc[`PairUtil`] 
| This `struct` provides a namespace for the functions that make working with `bsl&colon;&colon;pair`&hyphen;like containers more convenient or adapting such containers to work with standard library utilities&period;
| xref:BloombergLP/bdlb/PcgRandomGenerator.adoc[`PcgRandomGenerator`] 
| This class implements a random number generator (RNG) based on the PCG algorithm&period;
| xref:BloombergLP/bdlb/Print.adoc[`Print`] 
| Provide a namespace for the interface to a suite of procedural stream operations&period;
| xref:BloombergLP/bdlb/PrintAdapter.adoc[`PrintAdapter`] 
| This `class` provides an object that may be streamed with `operator&lt;&lt;` to give full control of the indentation format of the streaming&period;
| xref:BloombergLP/bdlb/PrintAdapterUtil.adoc[`PrintAdapterUtil`] 
| Utility for constructing a `PrintAdapter` without naming its template argument (useful in C&plus;&plus;03&semi; CTAD can replace this in C&plus;&plus;17&plus;)&period;
| xref:BloombergLP/bdlb/PrintMethods_Imp-0c.adoc[`PrintMethods&lowbar;Imp&lt;TYPE, bslmf::SelectTraitCase&lt;&gt;&gt;`] 
| Component&hyphen;private `struct`&period; Do not use outside of this component&period; This `struct` provides a `print` function that prints objects of parameterized `TYPE` that do not declare any of the traits recognized by this component&period;
| xref:BloombergLP/bdlb/PrintMethods_Imp-08.adoc[`PrintMethods&lowbar;Imp&lt;TYPE, bslmf::SelectTraitCase&lt;HasPrintMethod&gt;&gt;`] 
| Component&hyphen;private `struct`&period; Do not use outside of this component&period; This `struct` provides a `print` function that prints objects of the parameterized `TYPE` that are associated with the `HasPrintMethod` trait&period;
| xref:BloombergLP/bdlb/PrintMethods_Imp-05.adoc[`PrintMethods&lowbar;Imp&lt;TYPE, bslmf::SelectTraitCase&lt;HasStlIterators&gt;&gt;`] 
| Component&hyphen;private `struct`&period; Do not use outside of this component&period; This `struct` provides a `print` function that prints objects of the parameterized `TYPE` that have the `bslalg&colon;&colon;HasStlIterators` trait declared&period;
| xref:BloombergLP/bdlb/PrintMethods_Imp-09.adoc[`PrintMethods&lowbar;Imp&lt;TYPE, bslmf::SelectTraitCase&lt;IsPair&gt;&gt;`] 
| Component&hyphen;private `struct`&period; Do not use outside of this component&period; This `struct` provides a `print` function that prints objects of parameterized `TYPE` that declare the `bslmf&colon;&colon;IsPair` trait&period;
| xref:BloombergLP/bdlb/PrintStringHexDumper.adoc[`PrintStringHexDumper`] 
| Utility for hex dumping a blob to standard output streams&period; This class has `operator&lt;&lt;` defined for it, so it can be used as follows&colon; &grave; bsl&colon;&colon;vector&lt;char&gt; blob&semi; blob&period;resize(1024)&semi;
| xref:BloombergLP/bdlb/PrintStringSingleLineHexDumper.adoc[`PrintStringSingleLineHexDumper`] 
| Utility for hex dumping a string with no extra formatting to standard output streams&period; This class has `operator&lt;&lt;` defined for it, so it can be used as follows&colon; &grave; bsl&colon;&colon;string str&semi;
| xref:BloombergLP/bdlb/Random.adoc[`Random`] 
| This `struct` provides a namespace for a suite of functions used for random&hyphen;number generation&period;
| xref:BloombergLP/bdlb/RandomDevice.adoc[`RandomDevice`] 
| This `struct` provides a namespace for a suite of functions used for acquiring random numbers from the system&period;
| xref:BloombergLP/bdlb/ScopeExit-0e.adoc[`ScopeExit`] 
| `ScopeExit` is a general&hyphen;purpose scope proctor class template that is intended to be used as an automatic (stack) variable that calls an exit function upon its destruction (when its scope is exited)&period;
| xref:BloombergLP/bdlb/ScopeExitUtil.adoc[`ScopeExitUtil`] 
| A utility that provides a factory function for sufficiently function C&plus;&plus;11 or later platforms to create scope guards using the type&hyphen;deducing `auto` keyword&period; Notice that the utility type does not exist on C&plus;&plus;03 platforms&period;
| xref:BloombergLP/bdlb/String.adoc[`String`] 
| This `struct` provides a namespace for a suite of functions on STL&hyphen;style strings (`bsl&colon;&colon;string`, `std&colon;&colon;string`, `std&colon;&colon;pmr&colon;&colon;string`), C&hyphen;style strings, and strings specified by a `(const char &ast;, int)` or `(char &ast;, int)` pair&period;
| xref:BloombergLP/bdlb/StringRefUtil.adoc[`StringRefUtil`] 
| This `struct` provides a namespace for a suite of functions on `bslstl&colon;&colon;StringRef` references to strings&period;
| xref:BloombergLP/bdlb/StringViewUtil.adoc[`StringViewUtil`] 
| This `struct` provides a namespace for a suite of functions on `bsl&colon;&colon;string&lowbar;view` containers&period;
| xref:BloombergLP/bdlb/Tokenizer.adoc[`Tokenizer`] 
| This class provides (read&hyphen;only) sequential access to tokens delimited by two user&hyphen;supplied character sets consisting, respectively, of _soft_ and _hard_ delimiters characters&period; Access to the previous and current (trailing) delimiter, as well as to the current token itself, is provided efficiently via `bslstl&colon;&colon;StringRef`&period;
| xref:BloombergLP/bdlb/TokenizerIterator.adoc[`TokenizerIterator`] 
| This class provides a C&plus;&plus;&hyphen;standards&hyphen;conforming input iterator over the tokens in the input string suppled at construction (along with the designation of _soft_ and _hard_ delimiter characters) to a `Tokenizer` object&period; Tokens are returned, using a `bslstl&colon;&colon;StringRef` &hyphen;&hyphen; by value &hyphen;&hyphen; that means the iterated references remain valid until the underlying input string itself is modified or destroyed&period; Note that all iterators are invalidated whenever the input string in the parent `Tokenizer` change&period;
| xref:BloombergLP/bdlb/Tokenizer_Data.adoc[`Tokenizer&lowbar;Data`] 
| This component&hyphen;private class is used to hold delimiter information&period; Each `Tokenizer` object will have, as a private data member, an object of this class, and will pass the address of that member to the (private) constructor of each `TokenizerIterator` object it issues&colon; &grave; &plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus; &verbar; ,&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&period; &verbar; &verbar; ( Tokenizer&lowbar;Data ) &verbar; &verbar; &grave;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&apos;&bsol; &verbar; &verbar; &verbar; &verbar; &verbar; &verbar; ,&hyphen;&hyphen;&hyphen;&hyphen;&ast;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&period; &verbar; &verbar; &verbar; ( TokenizerIterator ) &verbar; &verbar; &verbar; &sol;&grave;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&apos; &verbar; &verbar; &verbar; &sol; &verbar; &verbar; ,&hyphen;&hyphen;&hyphen;&hyphen;&ast;&hyphen;&hyphen;o&hyphen;&period; &verbar; &verbar; ( Tokenizer ) &verbar; &verbar; &grave;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&apos; &verbar; &plus;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&plus; bdlb&lowbar;tokenizer &grave;
| xref:BloombergLP/bdlb/Tokenizer_Proxy.adoc[`Tokenizer&lowbar;Proxy`] 
| This class provides a proxy holder of a reference to a `TokernizerIterator` object, allowing correct return of `operator&hyphen;&gt;`&period;
| xref:BloombergLP/bdlb/TopologicalSortUtil.adoc[`TopologicalSortUtil`] 
| This `struct` `TopologicalSortUtil` provides a namespace for topological sorting functions&period;
| xref:BloombergLP/bdlb/TopologicalSortUtilEdgeTraits-0c.adoc[`TopologicalSortUtilEdgeTraits`] 
| This `struct` represents a customization point allowing clients to supply input iterators to `sort` having a `value&lowbar;types` other than a `bsl&colon;&colon;pair`&period; Clients may specialize `TopologicalSortUtilEdgeTraits` to supply the following&colon; &grave; &sol;&sol;&sol; The type of the directed connection from one node to another &sol;&sol;&sol; `bsl&colon;&colon;pair&lt;NodeType, NodeType&gt;` and `std&colon;&colon;pair&lt;NodeType&gt;` work &sol;&sol;&sol; without `TopologicalSortUtilEdgeTraits` specialization&period; typedef EDGE&lowbar;TYPE EdgeType&semi;
| xref:BloombergLP/bdlb/TopologicalSortUtil_Helper.adoc[`TopologicalSortUtil&lowbar;Helper`] 
| This class template provides data structures required to sort the partial unsorted edges into a total ordered set of nodes&period; The value type of the nodes(&ast;) must be hashable and equality comparable by `bsl&colon;&colon;hash`, and `bsl&colon;&colon;equal&lowbar;to` respectively&period;
| xref:BloombergLP/bdlb/TransformIterator.adoc[`TransformIterator`] 
| The transform iterator class itself&period; Its job is to hold a functor and an iterator, pass through all iterator&hyphen;related operations to the held iterator, and on dereference, call the functor on the result of dereferencing the iterator and return the result of the call instead&period;
| xref:BloombergLP/bdlb/TransformIteratorUtil.adoc[`TransformIteratorUtil`] 
| This `struct` provides a namespace for a function template that simplifies the creation of `TransformIterator` objects by allowing type deduction to discover the types of the functor and underlying iterator&period;
| xref:BloombergLP/bdlb/TransformIterator_AllocatorOfFunctorMethod-01.adoc[`TransformIterator&lowbar;AllocatorOfFunctorMethod`] 
| The `TransformIterator&lowbar;AllocatorOfFunctorMethod` class template has an allocator method when its boolean template parameter is `true`, which will be made to be the case when the iterator of the transform iterator does not use allocators and the functor of the transform iterator uses allocators&period; The transform iterator type itself is supplied as `BASE&lowbar;TYPE`&period;
| xref:BloombergLP/bdlb/TransformIterator_AllocatorOfIteratorMethod-00.adoc[`TransformIterator&lowbar;AllocatorOfIteratorMethod`] 
| The `TransformIterator&lowbar;AllocatorOfIteratorMethod` class template has an allocator method when its boolean template parameter is `true`, which will be made to be the case when the iterator of the transform iterator uses allocators&period; The transform iterator type itself is supplied as `BASE&lowbar;TYPE`&period;
| xref:BloombergLP/bdlb/TransformIterator_Traits-0f.adoc[`TransformIterator&lowbar;Traits`] 
| This component&hyphen;private class defines various types that are used in the implementation of the transform iterator&period;
| xref:BloombergLP/bdlb/TransparentEqualTo.adoc[`TransparentEqualTo`] 
| This `struct` defines an equality of objects of different types, enabling them for use for heterogeneous comparison in the standard associative containers such as `bsl&colon;&colon;unordered&lowbar;map`&period; Note that this class is an empty POD type&period;
| xref:BloombergLP/bdlb/TransparentHash.adoc[`TransparentHash`] 
| This `struct` defines a hash operation for different types, enabling them for use for heterogeneous lookup in the standard associative containers such as `bsl&colon;&colon;unordered&lowbar;map`&period; Note that this class is an empty POD type&period;
| xref:BloombergLP/bdlb/TransparentLess.adoc[`TransparentLess`] 
| This `struct` defines an ordering on objects of different types, enabling them for use for heterogeneous comparison in the standard associative containers such as `bsl&colon;&colon;map` and `bsl&colon;&colon;set`&period; Note that this class is an empty POD type&period;
| xref:BloombergLP/bdlb/TransparentStringHash.adoc[`TransparentStringHash`] 
| This `struct` defines a hash operation for different string types, enabling them for use for heterogeneous lookup in the standard associative containers such as `bsl&colon;&colon;unordered&lowbar;map`&period; Note that this class is an empty POD type&period;
| xref:BloombergLP/bdlb/TypeTraitHasPrintMethod.adoc[`TypeTraitHasPrintMethod`] 
| A class should declare this trait if it has a `print` method with the following signature&colon; &grave; bsl&colon;&colon;ostream&amp; print(bsl&colon;&colon;ostream&amp; stream, int level &equals; 0, int spacesPerLevel &equals; 4) const&semi; &grave;
| xref:BloombergLP/bdlb/Variant.adoc[`Variant`] 
| 
| xref:BloombergLP/bdlb/Variant10.adoc[`Variant10`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (10) of types&period; Its 10 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A10&gt;`&period;
| xref:BloombergLP/bdlb/Variant11.adoc[`Variant11`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (11) of types&period; Its 11 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A11&gt;`&period;
| xref:BloombergLP/bdlb/Variant12.adoc[`Variant12`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (12) of types&period; Its 12 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A12&gt;`&period;
| xref:BloombergLP/bdlb/Variant13.adoc[`Variant13`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (13) of types&period; Its 13 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A13&gt;`&period;
| xref:BloombergLP/bdlb/Variant14.adoc[`Variant14`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (14) of types&period; Its 14 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A14&gt;`&period;
| xref:BloombergLP/bdlb/Variant15.adoc[`Variant15`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (15) of types&period; Its 15 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A15&gt;`&period;
| xref:BloombergLP/bdlb/Variant16.adoc[`Variant16`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (16) of types&period; Its 16 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A16&gt;`&period;
| xref:BloombergLP/bdlb/Variant17.adoc[`Variant17`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (17) of types&period; Its 17 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A17&gt;`&period;
| xref:BloombergLP/bdlb/Variant18.adoc[`Variant18`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (18) of types&period; Its 18 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A18&gt;`&period;
| xref:BloombergLP/bdlb/Variant19.adoc[`Variant19`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (19) of types&period; Its 19 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A19&gt;`&period;
| xref:BloombergLP/bdlb/Variant2.adoc[`Variant2`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (2) of types&period; Its 2 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2&gt;`&period;
| xref:BloombergLP/bdlb/Variant3.adoc[`Variant3`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (3) of types&period; Its 3 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, A3&gt;`&period;
| xref:BloombergLP/bdlb/Variant4.adoc[`Variant4`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (4) of types&period; Its 4 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A4&gt;`&period;
| xref:BloombergLP/bdlb/Variant5.adoc[`Variant5`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (5) of types&period; Its 5 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A5&gt;`&period;
| xref:BloombergLP/bdlb/Variant6.adoc[`Variant6`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (6) of types&period; Its 6 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A6&gt;`&period;
| xref:BloombergLP/bdlb/Variant7.adoc[`Variant7`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (7) of types&period; Its 7 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A7&gt;`&period;
| xref:BloombergLP/bdlb/Variant8.adoc[`Variant8`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (8) of types&period; Its 8 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A8&gt;`&period;
| xref:BloombergLP/bdlb/Variant9.adoc[`Variant9`] 
| This class is a &quot;specialization&quot; of `Variant` for a fixed number (9) of types&period; Its 9 template arguments _must_ all be specified (none are defaulted to `bslmf&colon;&colon;Nil`)&period; It provides the same functionality as `Variant&lt;A1, A2, &period;&period;&period;, A9&gt;`&period;
| xref:BloombergLP/bdlb/VariantImp.adoc[`VariantImp`] 
| This class provides the implementation of `Variant` (except for the creators) given a list of template parameter `TYPES`&period;
| xref:BloombergLP/bdlb/VariantImp_AllocatorBase.adoc[`VariantImp&lowbar;AllocatorBase`] 
| This class is component&hyphen;private&period; Do not use&period; This class contains the `typedef`s and data members of the `Variant` class, and serves as the base class for the variant when any one of the types held by the variant has the `bslma&colon;&colon;UsesBslmaAllocator` type trait&period;
| xref:BloombergLP/bdlb/VariantImp_NoAllocatorBase.adoc[`VariantImp&lowbar;NoAllocatorBase`] 
| This class is component&hyphen;private&period; Do not use&period; This class contains the `typedef`s and data members of the `Variant` class, and serves as the base class for the variant when none of the types held by the variant has the `bslma&colon;&colon;UsesBslmaAllocator` type trait&period; The goal is to optimize the size of the variant to avoid holding an unnecessary allocator pointer&period;
| xref:BloombergLP/bdlb/VariantImp_Traits.adoc[`VariantImp&lowbar;Traits`] 
| This struct is component&hyphen;private&period; Do not use&period; This meta&hyphen;function selects `VariantImp&lowbar;AllocatorBase` as a base class type if any one of the types held by a variant has the `bslma&colon;&colon;UsesBslmaAllocator` trait, and `VariantImp&lowbar;NoAllocatorBase` otherwise&period;
| xref:BloombergLP/bdlb/VariantPrinter.adoc[`VariantPrinter`] 
| Utility for printing `bsl&colon;&colon;variant` to standard output streams&period; This class has `operator&lt;&lt;` defined for it, so it can be used, for example, in `ball` logs&period;
| xref:BloombergLP/bdlb/VariantPrinterUtil.adoc[`VariantPrinterUtil`] 
| This utility `struct` provides a namespace for a function that creates a `bdlb&colon;&colon;VariantPrinter` with its template argument deduced from a given instance of `bsl&colon;&colon;variant`&period;
| xref:BloombergLP/bdlb/VariantPrinter_Visitor.adoc[`VariantPrinter&lowbar;Visitor`] 
| Visitor for visiting `t&lowbar;TYPE` held by a variant and printing it&period;
| xref:BloombergLP/bdlb/Variant_BdexStreamInVisitor.adoc[`Variant&lowbar;BdexStreamInVisitor`] 
| This visitor, when invoked as a non&hyphen;modifiable function object on an initialized instance of some parameterized `TYPE`, will stream in a value of the same `TYPE` into that instance from a stream specified at construction of this visitor, using a version also specified at construction of this visitor&period;
| xref:BloombergLP/bdlb/Variant_BdexStreamOutVisitor.adoc[`Variant&lowbar;BdexStreamOutVisitor`] 
| This visitor, when invoked as a non&hyphen;modifiable function object on an initialized instance of some parameterized `TYPE`, will stream out the value of that instance into a stream specified at construction of this visitor, using a version also specified at construction of this visitor&period;
| xref:BloombergLP/bdlb/Variant_CopyAssignVisitor.adoc[`Variant&lowbar;CopyAssignVisitor`] 
| This visitor, when invoked as a non&hyphen;modifiable function object on an instance of some template parameter `TYPE`, will copy&hyphen;assign that instance to the instance of the same `TYPE` held in a buffer specified at construction of this visitor&period;
| xref:BloombergLP/bdlb/Variant_CopyConstructVisitor.adoc[`Variant&lowbar;CopyConstructVisitor`] 
| This visitor, when invoked as a non&hyphen;modifiable function object on an instance of some template parameter `TYPE`, will copy&hyphen;insert that instance to create an instance of the same `TYPE` in an uninitialized buffer specified at construction of this visitor&period;
| xref:BloombergLP/bdlb/Variant_DefaultConstructVisitor.adoc[`Variant&lowbar;DefaultConstructVisitor`] 
| This visitor, when invoked as a non&hyphen;modifiable function object on an instance of some template parameter `TYPE`, will create a default instance of `TYPE`&period;
| xref:BloombergLP/bdlb/Variant_DestructorVisitor.adoc[`Variant&lowbar;DestructorVisitor`] 
| This visitor, when invoked as a function object on an instance of some template parameter `TYPE`, will destroy that instance&period;
| xref:BloombergLP/bdlb/Variant_EqualityTestVisitor.adoc[`Variant&lowbar;EqualityTestVisitor`] 
| This visitor, when invoked as a non&hyphen;modifiable function object on an instance of some template parameter `TYPE`, tests the equality of the value of that instance and of another instance held in a buffer specified at construction of this visitor, and stores the result into its publicly accessible `d&lowbar;result` member&period;
| xref:BloombergLP/bdlb/Variant_MoveAssignVisitor.adoc[`Variant&lowbar;MoveAssignVisitor`] 
| This visitor, when invoked as a non&hyphen;modifiable function object on an instance of some template parameter `TYPE`, will move&hyphen;assign that instance to the instance of the same `TYPE` held in a buffer specified at construction of this visitor&period;
| xref:BloombergLP/bdlb/Variant_MoveConstructVisitor.adoc[`Variant&lowbar;MoveConstructVisitor`] 
| This visitor, when invoked as a non&hyphen;modifiable function object on an instance of some template parameter `TYPE`, will move&hyphen;insert that instance to create an instance of the same `TYPE` in an uninitialized buffer specified at construction of this visitor&period;
| xref:BloombergLP/bdlb/Variant_PrintVisitor.adoc[`Variant&lowbar;PrintVisitor`] 
| This visitor, when invoked as a non&hyphen;modifiable function object on an instance of some template parameter `TYPE`, writes the value of that instance to a stream specified at construction of this visitor, using spacing information also specified at construction&period;
| xref:BloombergLP/bdlb/Variant_RawVisitorHelper.adoc[`Variant&lowbar;RawVisitorHelper`] 
| This `struct` provides a helper for implementing `Variant&colon;&colon;applyRaw` that enables `applyRaw` to support visitor functors that do not provide an overload for `operator()(bslmf&colon;&colon;Nil)`&period; Objects of this type are constructed using a functor of (template parameter) type `VISITOR`, whose `operator()` returns the (template parameter) type `RESULT&lowbar;TYPE`&period; A `Variant&lowbar;RawVisitorHelper` wraps a functor of type `VISITOR` and provides an implementation of `operator()(bslmf&colon;&colon;Nil)` that performs a `BSLS&lowbar;ASSERT&lowbar;OPT(false)`&period; Note that this overload is needed to enable compilation (specifically, to instantiate `doApply` and `doApplyR`), but is never invoked by any code path at runtime&period;
| xref:BloombergLP/bdlb/Variant_ReturnValueHelper.adoc[`Variant&lowbar;ReturnValueHelper`] 
| This struct is a component&hyphen;private meta&hyphen;function&period; Do _not_ use&period; This meta&hyphen;function checks whether the template parameter type `VISITOR` has the member `ResultType` defined using &quot;SFINAE&quot; (Substitution Failure Is Not An Error)&period; A `value` of `true` indicates `VISITOR&colon;&colon;ResultType` exists, and `false` otherwise&period;
| xref:BloombergLP/bdlb/Variant_ReturnValueHelper_Matcher.adoc[`Variant&lowbar;ReturnValueHelper&lowbar;Matcher`] 
| This struct is a component&hyphen;private struct&period; Do _not_ use&period; This provides functions, the matching of which are used by Variant&lowbar;ReturnValueHelper to determine whether the template parameter type `VISITOR` has the member `ResultType` defined&period;
| xref:BloombergLP/bdlb/Variant_ReturnValueHelper_NoType.adoc[`Variant&lowbar;ReturnValueHelper&lowbar;NoType`] 
| Component&hyphen;private struct used by SFINAE detection when `ResultType` is absent&period;
| xref:BloombergLP/bdlb/Variant_SwapVisitor.adoc[`Variant&lowbar;SwapVisitor`] 
| This visitor swaps the variant object data that it holds with another variant object data of parameterize `TYPE`&period; It requires that the two variant objects being swapped contain data of the same type, and use the same allocator&period;
| xref:BloombergLP/bdlb/Variant_TypeIndex.adoc[`Variant&lowbar;TypeIndex`] 
| Component&hyphen;private meta&hyphen;function&period; Do not use&period; This meta&hyphen;function computes the index of the template parameter `TYPE` in the template parameter list of `TYPES`&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlb/NullOptType.adoc[`NullOptType`] 
| This `class` provides an empty tag type so that `bdlb&colon;&colon;NullableValue` can be explicitly constructed in or assigned to an empty state&period; There are no publicly accessible constructors for this type other than the copy constructor&period; In particular, it is not default constructible, nor list&hyphen;initializable in C&plus;&plus;11&period;
| xref:BloombergLP/bdlb/ScopeExitAny.adoc[`ScopeExitAny`] 
| `ScopeExitAny` is an alias to `ScopeExit&lt;bsl&colon;&colon;function&lt;void()&gt; &gt;`, effectively making it a polymorphic scope exit type&period;
| xref:BloombergLP/bdlb/TestInputIterator.adoc[`TestInputIterator`] 
| Alias for `bsltf&colon;&colon;InputIterator&lt;TYPE&gt;`&semi; a pure input iterator for an empty range, used to test algorithm compatibility with restrictive input iterators&period;
| xref:BloombergLP/bdlb/Variant_ReturnValueHelper_YesType.adoc[`Variant&lowbar;ReturnValueHelper&lowbar;YesType`] 
| Component&hyphen;private type used by SFINAE detection when `ResultType` exists&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlb/hashAppend-05.adoc[`hashAppend`] 
| `hashAppend` overloads
| xref:BloombergLP/bdlb/nullableValue_acceptsBslOptional.adoc[`nullableValue&lowbar;acceptsBslOptional`] 
| Component&hyphen;private constraint helper for `bsl&colon;&colon;optional` conversion&period;
| xref:BloombergLP/bdlb/nullableValue_acceptsStdOptional.adoc[`nullableValue&lowbar;acceptsStdOptional`] 
| Component&hyphen;private constraint helper for `std&colon;&colon;optional` conversion&period;
| xref:BloombergLP/bdlb/operator_plus-02.adoc[`operator&plus;`] 
| Return a copy of the specified `iterator` object with its underlying iterator advanced by the specified (signed) `offset` from that of `iterator`&period; The behavior is undefined if so advancing the underlying iterator is undefined&period;
| xref:BloombergLP/bdlb/operator_inc-055.adoc[`operator&plus;&plus;`] 
| Increment operators
| xref:BloombergLP/bdlb/operator_minus-07.adoc[`operator&hyphen;`] 
| Subtraction operators
| xref:BloombergLP/bdlb/operator_dec.adoc[`operator&hyphen;&hyphen;`] 
| Decrement the underlying iterator of the specified `iterator`, and return a copy of `iterator` _before_ the decrement&period; The behavior is undefined if decrementing the underlying iterator is undefined&period;
| xref:BloombergLP/bdlb/operator_bitor.adoc[`operator&verbar;`] 
| Translate the range of `bsl&colon;&colon;pair`s into a range of `std&colon;&colon;pair`s, where each `pair` of the resulting range is a `pair` of references to the corresponding members of the corresponding `pair` in the input range&period;
| xref:BloombergLP/bdlb/swap-09.adoc[`swap`] 
| `swap` overloads
| xref:BloombergLP/bdlb/operator_lshift-011.adoc[`operator&lt;&lt;`] 
| Stream insertion operators
| xref:BloombergLP/bdlb/operator_eq-064.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:BloombergLP/bdlb/operator_not_eq-067.adoc[`operator!&equals;`] 
| Inequality operators
| xref:BloombergLP/bdlb/operator_lt-046.adoc[`operator&lt;`] 
| Less&hyphen;than operators
| xref:BloombergLP/bdlb/operator_le-0e.adoc[`operator&lt;&equals;`] 
| Less&hyphen;than&hyphen;or&hyphen;equal operators
| xref:BloombergLP/bdlb/operator_gt-0dc.adoc[`operator&gt;`] 
| Greater&hyphen;than operators
| xref:BloombergLP/bdlb/operator_ge-064.adoc[`operator&gt;&equals;`] 
| Greater&hyphen;than&hyphen;or&hyphen;equal operators
| xref:BloombergLP/bdlb/operator_3way-0f.adoc[`operator&lt;&equals;&gt;`] 
| Three&hyphen;way comparison operators
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlb/nullOpt.adoc[`nullOpt`] 
| `bsl&colon;&colon;nullopt` value imported into the `bdlb` namespace&period;
|===


== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlb/NullableValue_ConvertibleToBool.adoc[`NullableValue&lowbar;ConvertibleToBool`] 
| This component&hyphen;private concept models the Standard&apos;s exposition&hyphen;only `boolean&hyphen;testable` concept&period;
| xref:BloombergLP/bdlb/NullableValue_DerivedFromBslOptional.adoc[`NullableValue&lowbar;DerivedFromBslOptional`] 
| This component&hyphen;private concept is used in the subsequent implementation of the component&hyphen;private concept `NullableValue&lowbar;DerivedFromOptional`&period;
| xref:BloombergLP/bdlb/NullableValue_DerivedFromOptional.adoc[`NullableValue&lowbar;DerivedFromOptional`] 
| This component&hyphen;private concept models whether a type is derived from one of `std&colon;&colon;optional`, or `bsl&colon;&colon;optional`&period; Note that this concept is always satisfied for `bdlb&colon;&colon;NullableValue` as it is derived from `bsl&colon;&colon;optional`&period;
| xref:BloombergLP/bdlb/NullableValue_DerivedFromStdOptional.adoc[`NullableValue&lowbar;DerivedFromStdOptional`] 
| This component&hyphen;private concept is used in the subsequent implementation of the component&hyphen;private concept `NullableValue&lowbar;DerivedFromOptional`&period;
|===



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