[#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`] 
| In&hyphen;core representation of a signed 16&hyphen;bit big&hyphen;endian integer&period;
| xref:BloombergLP/bdlb/BigEndianInt32.adoc[`BigEndianInt32`] 
| In&hyphen;core representation of a signed 32&hyphen;bit big&hyphen;endian integer&period;
| xref:BloombergLP/bdlb/BigEndianInt64.adoc[`BigEndianInt64`] 
| In&hyphen;core representation of a signed 64&hyphen;bit big&hyphen;endian integer&period;
| xref:BloombergLP/bdlb/BigEndianUint16.adoc[`BigEndianUint16`] 
| In&hyphen;core representation of an unsigned 16&hyphen;bit big&hyphen;endian integer&period;
| xref:BloombergLP/bdlb/BigEndianUint32.adoc[`BigEndianUint32`] 
| In&hyphen;core representation of an unsigned 32&hyphen;bit big&hyphen;endian integer&period;
| xref:BloombergLP/bdlb/BigEndianUint64.adoc[`BigEndianUint64`] 
| In&hyphen;core representation of an unsigned 64&hyphen;bit big&hyphen;endian integer&period;
| xref:BloombergLP/bdlb/BitMaskUtil.adoc[`BitMaskUtil`] 
| Namespace for functions that produce 32&hyphen; and 64&hyphen;bit bit masks&period;
| xref:BloombergLP/bdlb/BitStringImpUtil.adoc[`BitStringImpUtil`] 
| Namespace for static bit&hyphen;manipulation helpers used by `BitStringUtil`&period;
| xref:BloombergLP/bdlb/BitStringUtil.adoc[`BitStringUtil`] 
| Namespace for bit&hyphen;string utility functions&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`] 
| Equality comparison functor for null&hyphen;terminated character strings&period;
| xref:BloombergLP/bdlb/CStringHash.adoc[`CStringHash`] 
| Hash functor for null&hyphen;terminated C&hyphen;strings&period;
| xref:BloombergLP/bdlb/CStringLess.adoc[`CStringLess`] 
| Less&hyphen;than functor for null&hyphen;terminated character strings&period;
| xref:BloombergLP/bdlb/CaselessStringViewEqualTo.adoc[`CaselessStringViewEqualTo`] 
| Case&hyphen;insensitive equality comparison functor for string views&period;
| xref:BloombergLP/bdlb/CaselessStringViewHash.adoc[`CaselessStringViewHash`] 
| Case&hyphen;insensitive hash functor for string views&period;
| xref:BloombergLP/bdlb/CaselessStringViewLess.adoc[`CaselessStringViewLess`] 
| Case&hyphen;insensitive less&hyphen;than functor for string views&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`] 
| Namespace for fuzzy comparison functions on `double` 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 invokes a client&hyphen;supplied functor&period;
| xref:BloombergLP/bdlb/Guid.adoc[`Guid`] 
| This class implements a value&hyphen;semantic `Guid` type&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`] 
| Component&hyphen;private implementation of `bsl&colon;&colon;formatter` for `bdlb&colon;&colon;Guid`&period;
| xref:BloombergLP/bdlb/HasPrintMethod-03cc8.adoc[`HasPrintMethod`] 
| Trait metafunction indicating that `TYPE` provides a BDE&hyphen;style `print` method&period;
| 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;
| 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`] 
| Template for a nullable `TYPE` that may be allocated out&hyphen;of&hyphen;place&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`] 
| Value&hyphen;semantic wrapper that adds a null state to `TYPE`&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`] 
| Utility for creating `OptionalPrinter` objects with deduced template arguments&period;
| xref:BloombergLP/bdlb/PairUtil.adoc[`PairUtil`] 
| This `struct` provides a namespace for `bsl&colon;&colon;pair` 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 `print` implementation for types with no recognized print trait&period;
| xref:BloombergLP/bdlb/PrintMethods_Imp-08.adoc[`PrintMethods&lowbar;Imp&lt;TYPE, bslmf::SelectTraitCase&lt;HasPrintMethod&gt;&gt;`] 
| Component&hyphen;private `print` implementation for types 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 `print` implementation for types with the `HasStlIterators` trait&period;
| xref:BloombergLP/bdlb/PrintMethods_Imp-09.adoc[`PrintMethods&lowbar;Imp&lt;TYPE, bslmf::SelectTraitCase&lt;IsPair&gt;&gt;`] 
| Component&hyphen;private `print` implementation for types with the `IsPair` trait&period;
| xref:BloombergLP/bdlb/PrintStringHexDumper.adoc[`PrintStringHexDumper`] 
| Utility for hex dumping a blob to standard output streams&period;
| xref:BloombergLP/bdlb/PrintStringSingleLineHexDumper.adoc[`PrintStringSingleLineHexDumper`] 
| Utility for single&hyphen;line hex dumping of a string to output streams&period;
| 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`] 
| Scope proctor that invokes an exit function when destroyed&period;
| xref:BloombergLP/bdlb/ScopeExitUtil.adoc[`ScopeExitUtil`] 
| Utility providing a factory for type&hyphen;deduced `ScopeExit` guards&period;
| xref:BloombergLP/bdlb/String.adoc[`String`] 
| Namespace for utility functions on STL&hyphen;style and C&hyphen;style strings&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`] 
| Provides sequential read&hyphen;only access to tokens with soft and hard delimiters&period;
| xref:BloombergLP/bdlb/TokenizerIterator.adoc[`TokenizerIterator`] 
| Input iterator over the tokens of a bound `Tokenizer` input string&period;
| xref:BloombergLP/bdlb/Tokenizer_Data.adoc[`Tokenizer&lowbar;Data`] 
| Component&hyphen;private class that holds soft and hard delimiter information&period;
| 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`] 
| Customization point for edge types other than `bsl&colon;&colon;pair`&period;
| xref:BloombergLP/bdlb/TopologicalSortUtil_Helper.adoc[`TopologicalSortUtil&lowbar;Helper`] 
| Helper that builds work&hyphen;set data for a topological sort&period;
| xref:BloombergLP/bdlb/TransformIterator.adoc[`TransformIterator`] 
| Wrapping iterator that invokes a functor on dereference&period;
| xref:BloombergLP/bdlb/TransformIteratorUtil.adoc[`TransformIteratorUtil`] 
| Utility for creating `TransformIterator` objects&period;
| xref:BloombergLP/bdlb/TransformIterator_AllocatorOfFunctorMethod-01.adoc[`TransformIterator&lowbar;AllocatorOfFunctorMethod`] 
| Base class template that optionally provides an `allocator` method&period;
| xref:BloombergLP/bdlb/TransformIterator_AllocatorOfIteratorMethod-00.adoc[`TransformIterator&lowbar;AllocatorOfIteratorMethod`] 
| Base class template that optionally provides an `allocator` method&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`] 
| Transparent equality comparison functor for heterogeneous lookup&period;
| xref:BloombergLP/bdlb/TransparentHash.adoc[`TransparentHash`] 
| Transparent hash functor for heterogeneous container lookup&period;
| xref:BloombergLP/bdlb/TransparentLess.adoc[`TransparentLess`] 
| Transparent less&hyphen;than functor for heterogeneous comparison&period;
| xref:BloombergLP/bdlb/TransparentStringHash.adoc[`TransparentStringHash`] 
| This `struct` defines a transparent hash functor for string&hyphen;like types&period;
| xref:BloombergLP/bdlb/TypeTraitHasPrintMethod.adoc[`TypeTraitHasPrintMethod`] 
| Old&hyphen;style trait tag indicating that a class provides a BDE&hyphen;style `print` method&period;
| xref:BloombergLP/bdlb/Variant.adoc[`Variant`] 
| Discriminated union that holds a value of one of up to 20 alternative types&period;
| xref:BloombergLP/bdlb/Variant10.adoc[`Variant10`] 
| Fixed&hyphen;arity specialization of `Variant` for 10 types&period;
| xref:BloombergLP/bdlb/Variant11.adoc[`Variant11`] 
| Fixed&hyphen;arity specialization of `Variant` for 11 types&period;
| xref:BloombergLP/bdlb/Variant12.adoc[`Variant12`] 
| Fixed&hyphen;arity specialization of `Variant` for 12 types&period;
| xref:BloombergLP/bdlb/Variant13.adoc[`Variant13`] 
| Fixed&hyphen;arity specialization of `Variant` for 13 types&period;
| xref:BloombergLP/bdlb/Variant14.adoc[`Variant14`] 
| Fixed&hyphen;arity specialization of `Variant` for 14 types&period;
| xref:BloombergLP/bdlb/Variant15.adoc[`Variant15`] 
| Fixed&hyphen;arity specialization of `Variant` for 15 types&period;
| xref:BloombergLP/bdlb/Variant16.adoc[`Variant16`] 
| Fixed&hyphen;arity specialization of `Variant` for 16 types&period;
| xref:BloombergLP/bdlb/Variant17.adoc[`Variant17`] 
| Fixed&hyphen;arity specialization of `Variant` for 17 types&period;
| xref:BloombergLP/bdlb/Variant18.adoc[`Variant18`] 
| Fixed&hyphen;arity specialization of `Variant` for 18 types&period;
| xref:BloombergLP/bdlb/Variant19.adoc[`Variant19`] 
| Fixed&hyphen;arity specialization of `Variant` for 19 types&period;
| xref:BloombergLP/bdlb/Variant2.adoc[`Variant2`] 
| Fixed&hyphen;arity specialization of `Variant` for 2 types&period;
| xref:BloombergLP/bdlb/Variant3.adoc[`Variant3`] 
| Fixed&hyphen;arity specialization of `Variant` for 3 types&period;
| xref:BloombergLP/bdlb/Variant4.adoc[`Variant4`] 
| Fixed&hyphen;arity specialization of `Variant` for 4 types&period;
| xref:BloombergLP/bdlb/Variant5.adoc[`Variant5`] 
| Fixed&hyphen;arity specialization of `Variant` for 5 types&period;
| xref:BloombergLP/bdlb/Variant6.adoc[`Variant6`] 
| Fixed&hyphen;arity specialization of `Variant` for 6 types&period;
| xref:BloombergLP/bdlb/Variant7.adoc[`Variant7`] 
| Fixed&hyphen;arity specialization of `Variant` for 7 types&period;
| xref:BloombergLP/bdlb/Variant8.adoc[`Variant8`] 
| Fixed&hyphen;arity specialization of `Variant` for 8 types&period;
| xref:BloombergLP/bdlb/Variant9.adoc[`Variant9`] 
| Fixed&hyphen;arity specialization of `Variant` for 9 types&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`] 
| Component&hyphen;private base holding variant storage and type index&period;
| xref:BloombergLP/bdlb/VariantImp_NoAllocatorBase.adoc[`VariantImp&lowbar;NoAllocatorBase`] 
| Component&hyphen;private base holding variant storage and type index&period;
| xref:BloombergLP/bdlb/VariantImp_Traits.adoc[`VariantImp&lowbar;Traits`] 
| Component&hyphen;private traits selecting the variant allocator base&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`] 
| Utility for creating `VariantPrinter` objects with deduced template arguments&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`] 
| Visitor that operates on the currently held alternative&period;
| xref:BloombergLP/bdlb/Variant_BdexStreamOutVisitor.adoc[`Variant&lowbar;BdexStreamOutVisitor`] 
| Visitor that operates on the currently held alternative&period;
| xref:BloombergLP/bdlb/Variant_CopyAssignVisitor.adoc[`Variant&lowbar;CopyAssignVisitor`] 
| Visitor that operates on the currently held alternative&period;
| xref:BloombergLP/bdlb/Variant_CopyConstructVisitor.adoc[`Variant&lowbar;CopyConstructVisitor`] 
| Visitor that operates on the currently held alternative&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`] 
| Visitor that operates on the currently held alternative&period;
| xref:BloombergLP/bdlb/Variant_MoveAssignVisitor.adoc[`Variant&lowbar;MoveAssignVisitor`] 
| Visitor that operates on the currently held alternative&period;
| xref:BloombergLP/bdlb/Variant_MoveConstructVisitor.adoc[`Variant&lowbar;MoveConstructVisitor`] 
| Visitor that operates on the currently held alternative&period;
| xref:BloombergLP/bdlb/Variant_PrintVisitor.adoc[`Variant&lowbar;PrintVisitor`] 
| Visitor that operates on the currently held alternative&period;
| xref:BloombergLP/bdlb/Variant_RawVisitorHelper.adoc[`Variant&lowbar;RawVisitorHelper`] 
| Helper that adapts visitors lacking a `bslmf&colon;&colon;Nil` overload&period;
| xref:BloombergLP/bdlb/Variant_ReturnValueHelper.adoc[`Variant&lowbar;ReturnValueHelper`] 
| Component&hyphen;private helper that detects a visitor `ResultType`&period;
| xref:BloombergLP/bdlb/Variant_ReturnValueHelper_Matcher.adoc[`Variant&lowbar;ReturnValueHelper&lowbar;Matcher`] 
| Component&hyphen;private helper that detects a visitor `ResultType`&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;
| 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`] 
| Tag type representing an empty nullable value&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 `iterator` advanced by the specified `offset`&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 `iterator` and return a copy of its previous value&period;
| xref:BloombergLP/bdlb/operator_bitor.adoc[`operator&verbar;`] 
| Translate a range of `bsl&colon;&colon;pair`s into a range of `std&colon;&colon;pair`s&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`] 
| Component&hyphen;private concept for types derived from `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]#
