[#index]
= Global namespace
:mrdocs:

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP.adoc[`BloombergLP`] 
| The History&hyphen; &hyphen; &hyphen; &hyphen; &hyphen; &hyphen;
| xref:bsl.adoc[`bsl`] 
| Namespace containing forward declarations for standard stream classes&period;
|===


== Macros

[cols="1,4"]
|===
| Name| Description
| xref:BALXML_DECODER_LOG_END.adoc[`BALXML&lowbar;DECODER&lowbar;LOG&lowbar;END`] 
| See usage of BALXML&lowbar;DECODER&lowbar;LOG&lowbar;ERROR and BALXML&lowbar;DECODER&lowbar;LOG&lowbar;WARNING, above&period;
| xref:BALXML_DECODER_LOG_ERROR.adoc[`BALXML&lowbar;DECODER&lowbar;LOG&lowbar;ERROR`] 
| Usage&colon; BAEXML&lowbar;LOG&lowbar;ERROR(myDecoder) &lt;&lt; &quot;Message&quot; &lt;&lt; value &lt;&lt; BALXML&lowbar;DECODER&lowbar;LOG&lowbar;END&semi;
| xref:BALXML_DECODER_LOG_WARNING.adoc[`BALXML&lowbar;DECODER&lowbar;LOG&lowbar;WARNING`] 
| Usage&colon; BAEXML&lowbar;LOG&lowbar;WARNING(myDecoder) &lt;&lt; &quot;Message&quot; &lt;&lt; value &lt;&lt; BALXML&lowbar;DECODER&lowbar;LOG&lowbar;END&semi;
| xref:BAL_VERSION.adoc[`BAL&lowbar;VERSION`] 
| Construct an integer (unique to the specified `BAL&lowbar;VERSION&lowbar;MAJOR` and `BAL&lowbar;VERSION&lowbar;MINOR` numbers) corresponding to the major and minor version numbers, respectively, of the current (latest) BAL release&period; Note that the patch version number is intentionally not included&period; The exact format of the result is an implementation detail of `bslscm&lowbar;versiontag`&period; The major and minor parts of the resulting version can be extracted with `BSL&lowbar;GET&lowbar;VERSION&lowbar;MAJOR` and `BSL&lowbar;GET&lowbar;VERSION&lowbar;MINOR` respectively&period;
| xref:BAL_VERSION_DEPRECATION_THRESHOLD.adoc[`BAL&lowbar;VERSION&lowbar;DEPRECATION&lowbar;THRESHOLD`] 
| Declare that deprecations for this UOR introduced in the specified version or earlier will be &quot;active&quot; by default &hyphen;&hyphen; i&period;e&period;, `BSLS&lowbar;DEPRECATE&lowbar;IS&lowbar;ACTIVE` will be `true` (which typically enables deprecation warnings)&period; Note that we define this macro in the version component, so that it is available at the lowest level in the component hierarchy of this UOR&period;
| xref:BAL_VERSION_MAJOR.adoc[`BAL&lowbar;VERSION&lowbar;MAJOR`] 
| BAL release major version
| xref:BAL_VERSION_MINOR.adoc[`BAL&lowbar;VERSION&lowbar;MINOR`] 
| BAL release major version
| xref:BBL_VERSION.adoc[`BBL&lowbar;VERSION`] 
| Construct an integer (unique to the specified `BBL&lowbar;VERSION&lowbar;MAJOR` and `BBL&lowbar;VERSION&lowbar;MINOR` numbers) corresponding to the major and minor version numbers, respectively, of the current (latest) BBL release&period; Note that the patch version number is intentionally not included&period; The exact format of the result is an implementation detail of `bslscm&lowbar;versiontag`&period; The major and minor parts of the resulting version can be extracted with `BSL&lowbar;GET&lowbar;VERSION&lowbar;MAJOR` and `BSL&lowbar;GET&lowbar;VERSION&lowbar;MINOR` respectively&period;
| xref:BBL_VERSION_DEPRECATION_THRESHOLD.adoc[`BBL&lowbar;VERSION&lowbar;DEPRECATION&lowbar;THRESHOLD`] 
| Declare that deprecations for this UOR introduced in the specified version or earlier will be &quot;active&quot; by default &hyphen;&hyphen; i&period;e&period;, `BSLS&lowbar;DEPRECATE&lowbar;IS&lowbar;ACTIVE` will be `true` (which typically enables deprecation warnings)&period; Note that we define this macro in the version component, so that it is available at the lowest level in the component hierarchy of this UOR&period;
| xref:BBL_VERSION_MAJOR.adoc[`BBL&lowbar;VERSION&lowbar;MAJOR`] 
| Provide the major version number of the current (latest) BBL release&period;
| xref:BBL_VERSION_MINOR.adoc[`BBL&lowbar;VERSION&lowbar;MINOR`] 
| Provide the minor version number of the current (latest) BBL release&period;
| xref:BDEALG_DECLARE_NESTED_TRAITS.adoc[`BDEALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS`] 
| This alias is defined for backward compatibility&period;
| xref:BDEALG_DECLARE_NESTED_TRAITS2.adoc[`BDEALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS2`] 
| This alias is defined for backward compatibility&period;
| xref:BDEALG_DECLARE_NESTED_TRAITS3.adoc[`BDEALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS3`] 
| This alias is defined for backward compatibility&period;
| xref:BDEALG_DECLARE_NESTED_TRAITS4.adoc[`BDEALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS4`] 
| This alias is defined for backward compatibility&period;
| xref:BDEALG_DECLARE_NESTED_TRAITS5.adoc[`BDEALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS5`] 
| This alias is defined for backward compatibility&period;
| xref:BDLB_ARRAYUTIL_LENGTH.adoc[`BDLB&lowbar;ARRAYUTIL&lowbar;LENGTH`] 
| Return the number of elements in the passed array `a` as a constant expression&period;
| xref:BDLB_ARRAYUTIL_SIZE.adoc[`BDLB&lowbar;ARRAYUTIL&lowbar;SIZE`] 
| Return the number of elements in the passed array `a` as a constant expression&period;
| xref:BDLB_BITUTIL_USE_GNU_INTRINSICS.adoc[`BDLB&lowbar;BITUTIL&lowbar;USE&lowbar;GNU&lowbar;INTRINSICS`] 
| Use optimal intrinsics that know about CPU instruction sets on compilers the recognize the Gnu intrinsic spellings&period;
| xref:BDLB_SCOPEEXIT_GUARD.adoc[`BDLB&lowbar;SCOPEEXIT&lowbar;GUARD`] 
| Create a local variable with a generated unique name and with a type that is an instantiation of `bdlb&colon;&colon;ScopeExit` initialized with the specified `EXIT&lowbar;FUNC`&period; Note that the specific type of `bdlb&colon;&colon;ScopeExit` used will depend on available language features&period; The behavior is undefined if this macro is used (expanded) more than once on the same source line&period; Note that using this macro in another macro more than once is equivalent to using it more than once on the same source line&period;
| xref:BDLB_SCOPEEXIT_PRIVATE_CAT.adoc[`BDLB&lowbar;SCOPEEXIT&lowbar;PRIVATE&lowbar;CAT`] 
| This macro is for use by `BDLB&lowbar;SCOPEEXIT&lowbar;GUARD` only to provide unique variable names&period; It is _not_ undefined by the end of the file but its direct use is not supported under any circumstances&period;
| xref:BDLB_SCOPEEXIT_PRIVATE_CAT_IMP.adoc[`BDLB&lowbar;SCOPEEXIT&lowbar;PRIVATE&lowbar;CAT&lowbar;IMP`] 
| This macro is for use by `BDLB&lowbar;SCOPEEXIT&lowbar;GUARD` only to provide unique variable names&period; It is _not_ undefined by the end of the file but its direct use is not supported under any circumstances&period;
| xref:BDLB_SCOPEEXIT_USES_MODERN_CPP.adoc[`BDLB&lowbar;SCOPEEXIT&lowbar;USES&lowbar;MODERN&lowbar;CPP`] 
| This macro determines if we have a sufficiently functional C&plus;&plus;11 or later compiler so the type&hyphen;deducing `auto` with factory&hyphen;method can be compiled and works as expected&period; When the macro is not defined (C&plus;&plus;03 form) no utility `struct` (therefore no factory method) will be defined by this component and the variable definition macros (for Proctor and Guard) will use `bdlb&colon;&colon;ScopeExitAny`&period; When this macro is defined (C&plus;&plus;11 or later that has sufficiently operation rvalue references and type&hyphen;deducing `auto` keyword implementation) the factory method and its utility `struct` will be defined and the variable definition macros will use `auto` to determine the type of the `bdlb&colon;&colon;ScopeExit` variable&period; This macro is only internally in this component header and therefore it is undefined at the end of the file&period;
| xref:BDLB_VARIANT_USING_VARIADIC_TEMPLATES.adoc[`BDLB&lowbar;VARIANT&lowbar;USING&lowbar;VARIADIC&lowbar;TEMPLATES`] 
| Note that this macro definition parallels that of a similar macro defined in `bslmf&lowbar;typelist&period;h`&period;
| xref:BDL_VERSION.adoc[`BDL&lowbar;VERSION`] 
| Construct an integer (unique to the specified `BDL&lowbar;VERSION&lowbar;MAJOR` and `BDL&lowbar;VERSION&lowbar;MINOR` numbers) corresponding to the major and minor version numbers, respectively, of the current (latest) BDL release&period; Note that the patch version number is intentionally not included&period; The exact format of the result is an implementation detail of `bslscm&lowbar;versiontag`&period; The major and minor parts of the resulting version can be extracted with `BSL&lowbar;GET&lowbar;VERSION&lowbar;MAJOR` and `BSL&lowbar;GET&lowbar;VERSION&lowbar;MINOR` respectively&period;
| xref:BDL_VERSION_DEPRECATION_THRESHOLD.adoc[`BDL&lowbar;VERSION&lowbar;DEPRECATION&lowbar;THRESHOLD`] 
| Declare that deprecations for this UOR introduced in the specified version or earlier will be &quot;active&quot; by default &hyphen;&hyphen; i&period;e&period;, `BSLS&lowbar;DEPRECATE&lowbar;IS&lowbar;ACTIVE` will be `true` (which typically enables deprecation warnings)&period; Note that we define this macro in the version component, so that it is available at the lowest level in the component hierarchy of this UOR&period;
| xref:BDL_VERSION_MAJOR.adoc[`BDL&lowbar;VERSION&lowbar;MAJOR`] 
| Provide the major version number of the current (latest) BDL release&period;
| xref:BDL_VERSION_MINOR.adoc[`BDL&lowbar;VERSION&lowbar;MINOR`] 
| Provide the minor version number of the current (latest) BDL release&period;
| xref:BSLALG_DECLARE_NESTED_TRAITS.adoc[`BSLALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS`] 
| Associate the specified `TRAIT` tag with the specified `T` class&period; This macro must be invoked only within the public part of the definition of class `T`&period; `TRAIT` must name a class such that `TRAIT&colon;&colon;NestedTraitDeclaration&lt;T&gt;` designates a class derived from `bslmf&colon;&colon;DetectNestedTrait`&period;
| xref:BSLALG_DECLARE_NESTED_TRAITS2.adoc[`BSLALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS2`] 
| Like `BSLALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS`, but for two traits&period;
| xref:BSLALG_DECLARE_NESTED_TRAITS3.adoc[`BSLALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS3`] 
| Like `BSLALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS`, but for three traits&period;
| xref:BSLALG_DECLARE_NESTED_TRAITS4.adoc[`BSLALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS4`] 
| Like `BSLALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS`, but for four traits&period;
| xref:BSLALG_DECLARE_NESTED_TRAITS5.adoc[`BSLALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS5`] 
| Like `BSLALG&lowbar;DECLARE&lowbar;NESTED&lowbar;TRAITS`, but for five traits&period;
| xref:BSLIM_TESTUTIL_L_.adoc[`BSLIM&lowbar;TESTUTIL&lowbar;L&lowbar;`] 
| current Line number
| xref:BSLIM_TESTUTIL_P.adoc[`BSLIM&lowbar;TESTUTIL&lowbar;P`] 
| Print identifier and its value&period;
| xref:BSLIM_TESTUTIL_P_.adoc[`BSLIM&lowbar;TESTUTIL&lowbar;P&lowbar;`] 
| `P(X)` without &grave;
&grave;
| xref:BSLIM_TESTUTIL_Q.adoc[`BSLIM&lowbar;TESTUTIL&lowbar;Q`] 
| Quote identifier literally&period;
| xref:BSLIM_TESTUTIL_T_.adoc[`BSLIM&lowbar;TESTUTIL&lowbar;T&lowbar;`] 
| Print tab (w&sol;o newline)&period;
| xref:BSLMA_USESBSLMAALLOCATOR_CAT_IMP2.adoc[`BSLMA&lowbar;USESBSLMAALLOCATOR&lowbar;CAT&lowbar;IMP2`] 
| Component&hyphen;local macros for concatenating tokens&period;
| xref:BSLMA_USESBSLMAALLOCATOR_DEPRECATE_IF.adoc[`BSLMA&lowbar;USESBSLMAALLOCATOR&lowbar;DEPRECATE&lowbar;IF`] 
| On platforms that support a deprecation attribute, produce a deprecation warning if the specified `COND` is true, otherwise do nothing&period; The specified `MSG` is ignored, but must be a string literal and should describe why the condition (if true) is undesirable&period;
| xref:BSLMF_METAINT_TO_BOOL.adoc[`BSLMF&lowbar;METAINT&lowbar;TO&lowbar;BOOL`] 
| Given an integral value, `V`, and an expression, `expr`, of type `bslmf&colon;&colon;MetaInt&lt;V&gt;`, this macro returns a compile&hyphen;time constant with value, `true` or `false`, according to the Boolean value of `V`&period; The expression, `expr`, is not evaluated at run&hyphen;time&period;
| xref:BSLMF_METAINT_TO_INT.adoc[`BSLMF&lowbar;METAINT&lowbar;TO&lowbar;INT`] 
| Given an integral value, `V`, and an expression, `expr`, of type `bslmf&colon;&colon;MetaInt&lt;V&gt;`, this macro returns a compile&hyphen;time constant with value, `V`&period; The expression, `expr`, is not evaluated at run&hyphen;time&period;
| xref:BSLMF_MOVABLEREF_DEDUCE.adoc[`BSLMF&lowbar;MOVABLEREF&lowbar;DEDUCE`] 
| This macro expands to a movable reference to `*VA&lowbar;ARGS*` for which the arguments are deducible in all language versions&period; Note that the argument list of this macro is variadic in order to support deducing template arguments, e&period;g&period;, this macro supports uses like `BSLMF&lowbar;MOVABLEREF&lowbar;DEDUCE(bsl&colon;&colon;pair&lt;T1, T2&gt;)` for which the types `T1` and `T2` are deducible, even though the macro argument contains a comma&period;
| xref:BSLMF_SWITCH_USING_VARIADIC_TEMPLATES.adoc[`BSLMF&lowbar;SWITCH&lowbar;USING&lowbar;VARIADIC&lowbar;TEMPLATES`] 
| This macro indicates that we have all the needed features for an implementation of the type&hyphen;switch facility that is source&hyphen;compatible with the pre&hyphen;existing C&plus;&plus;03 facility&period; The main change is that the numbered classes Switch0&hyphen;Switch9 are no longer distinct classes, but aliases of specific instantiations of the primary Switch template&period; Eventually these partial template specializations will be eliminated, when the individually named members are no longer used throughout the whole of the Bloomberg codebase&period;
| xref:BSLMF_TYPEIDENTITY_T.adoc[`BSLMF&lowbar;TYPEIDENTITY&lowbar;T`] 
| Metafunction returning its type argument unchanged&period; Shorthand alias for `typename type&lowbar;identity&lt;&period;&period;&period;&gt;&colon;&colon;type`&period; The type argument to this macro must be a _dependent type_ of the function template or class template in which it is used, i&period;e&period;, a template parameter or type related to a template parameter&period; Note that this macro exists for compatibility with C&plus;&plus;03&semi; for C&plus;&plus;11 and later compilers, `bsl&colon;&colon;type&lowbar;identity&lowbar;t` is preferred&period;
| xref:BSLMF_TYPELIST_USING_VARIADIC_TEMPLATES.adoc[`BSLMF&lowbar;TYPELIST&lowbar;USING&lowbar;VARIADIC&lowbar;TEMPLATES`] 
| This macro indicates that we have all the needed features for an implementation of the typelist facility that is source&hyphen;compatible with the pre&hyphen;existing C&plus;&plus;03 facility&period; The main change is that the numbered classes TypeList0&hyphen;TypeList20 are no longer distinct classes, but aliases of specific instantiations of the primary TypeList template&period; Eventually these partial template specializations will be eliminated, when the individually named members are no longer used throughout the whole of the Bloomberg codebase&period;
| xref:BSLMT_ONCE_CANCEL.adoc[`BSLMT&lowbar;ONCE&lowbar;CANCEL`] 
| This macro provides a way to cancel once processing within a `BSLMT&lowbar;ONCE&lowbar;DO` construct&period; It will not compile outside of a `BSLMT&lowbar;ONCE&lowbar;DO` construct&period; Executing this function&hyphen;like macro will set the state of the `BSLMT&lowbar;ONCE&lowbar;DO` construct to &quot;not entered&quot;, possibly unblocking a thread waiting to enter the one&hyphen;time code region&period; Note that this macro does not exit the `BSLMT&lowbar;ONCE&lowbar;DO` construct (i&period;e&period;, it does not have `break` or `return` semantics)&period;
| xref:BSLMT_ONCE_DO.adoc[`BSLMT&lowbar;ONCE&lowbar;DO`] 
| This macro provides a simple control construct to bracket a piece of code that should only be executed once during the course of a multithreaded program&period; Usage&colon; &grave; BSLMT&lowbar;ONCE&lowbar;DO &lcub; &sol;&ast; one&hyphen;time code goes here &ast;&sol; &rcub; &grave; Leaving a `BSLMT&lowbar;ONCE&lowbar;DO` construct via `break`, `continue`, or `return` will put the construct in a &quot;done&quot; state (unless `BSLMT&lowbar;ONCE&lowbar;CANCEL` has been called) and will unblock all threads waiting to enter the one&hyphen;time region&period; Note that a `break` or `continue` within the one&hyphen;time code will terminate only the `BSLMT&lowbar;ONCE&lowbar;DO` construct, not any surrounding loop or switch statement&period; Due to a bug in the Microsoft Visual C&plus;&plus; 2003 compiler, the behavior is undefined if an exception is thrown from within this construct and is not caught within the same construct&period; Only one call to `BSLMT&lowbar;ONCE&lowbar;DO` may appear on a single source&hyphen;code line in any code block&period;
| xref:BSLMT_ONCE_INITIALIZER.adoc[`BSLMT&lowbar;ONCE&lowbar;INITIALIZER`] 
| Use this macro to initialize an object of type `Once`&period; E&period;g&period;&colon; &grave; Once once &equals; BSLMT&lowbar;ONCE&lowbar;INITIALIZER&semi; &grave;
| xref:BSLMT_QLOCK_INITIALIZER.adoc[`BSLMT&lowbar;QLOCK&lowbar;INITIALIZER`] 
| Use this macro as the value for initializing an object of type `QLock` For example&colon; &grave; QLock mylock &equals; BSLMT&lowbar;QLOCK&lowbar;INITIALIZER&semi; &grave;
| xref:BSLMT_TESTUTIL_CERR.adoc[`BSLMT&lowbar;TESTUTIL&lowbar;CERR`] 
| Equivalent to call to `bsl&colon;&colon;cerr` guarded by a `BSLMT&lowbar;TESTUTIL&lowbar;GUARD` whose scope ends at the end of the statement&period;
| xref:BSLMT_TESTUTIL_COUT.adoc[`BSLMT&lowbar;TESTUTIL&lowbar;COUT`] 
| Equivalent to call to `bsl&colon;&colon;cout` guarded by a `BSLMT&lowbar;TESTUTIL&lowbar;GUARD` whose scope ends at the end of the statement&period;
| xref:BSLMT_TESTUTIL_GUARD.adoc[`BSLMT&lowbar;TESTUTIL&lowbar;GUARD`] 
| Acquire the critical section, and release it when the macro call goes out of scope&period; If the critical section is already held by the current thread, this can still be used with no additional effect&period;
| xref:BSLMT_TESTUTIL_GUARDED_STREAM.adoc[`BSLMT&lowbar;TESTUTIL&lowbar;GUARDED&lowbar;STREAM`] 
| Enable output to the specified `STREAM` that will not be interleaved with output from `bslmt&lowbar;testutil` macros done by other threads&period; `STREAM` is expected to be a `bsl&colon;&colon;ostream` object, and this macro call can be output to with the C&plus;&plus; `&lt;&lt;` operator with all output until the terminating `&semi;` occurring as one non&hyphen;interleaved block&period;
| xref:BSLMT_TESTUTIL_L_.adoc[`BSLMT&lowbar;TESTUTIL&lowbar;L&lowbar;`] 
| current Line number
| xref:BSLMT_TESTUTIL_P.adoc[`BSLMT&lowbar;TESTUTIL&lowbar;P`] 
| Print identifier and its value&period;
| xref:BSLMT_TESTUTIL_P_.adoc[`BSLMT&lowbar;TESTUTIL&lowbar;P&lowbar;`] 
| `P(X)` without &grave;
&grave;
| xref:BSLMT_TESTUTIL_Q.adoc[`BSLMT&lowbar;TESTUTIL&lowbar;Q`] 
| Quote identifier literally&period;
| xref:BSLMT_TESTUTIL_T_.adoc[`BSLMT&lowbar;TESTUTIL&lowbar;T&lowbar;`] 
| Print tab (w&sol;o newline)&period; Do not put in a `do &lcub;&rcub; while(false)`, as this macro is intended to be called without a terminating `&semi;`&period;
| xref:BSLMT_THREAD_LOCAL_KEYWORD.adoc[`BSLMT&lowbar;THREAD&lowbar;LOCAL&lowbar;KEYWORD`] 
| DEPRECATED&colon; Use `BSLS&lowbar;KEYWORD&lowbar;THREAD&lowbar;LOCAL` instead&period;
| xref:BSLMT_THREAD_LOCAL_VARIABLE.adoc[`BSLMT&lowbar;THREAD&lowbar;LOCAL&lowbar;VARIABLE`] 
| Define, at function or namespace scope, a thread&hyphen;local `static` variable having the specified `VARIABLE&lowbar;NAME` of the specified `BASIC&lowbar;TYPE`, initialized with the specified `INITIAL&lowbar;VALUE`&period; If `VARIABLE&lowbar;NAME` is not a valid variable name, or `INITIAL&lowbar;VALUE` is not convertible to the type `BASIC&lowbar;TYPE`, the instantiation of this macro will result in a compile time error&period; The behavior is undefined unless `INITIAL&lowbar;VALUE` is a _compile_ _time_ constant value&period;
| xref:BSLSCM_PATCHVERSION_PATCH.adoc[`BSLSCM&lowbar;PATCHVERSION&lowbar;PATCH`] 
| Provide the patch version number of the current (latest) BSL release&period;
| xref:BSLSTL_OPTIONAL_CONSTEXPR17.adoc[`BSLSTL&lowbar;OPTIONAL&lowbar;CONSTEXPR17`] 
| `BSLSTL&lowbar;OPTIONAL&lowbar;CONSTEXPR17` controls whether constructors that are `constexpr` in C&plus;&plus;17 `std&colon;&colon;optional` are `constexpr` in `bsl&colon;&colon;optional` for allocator&hyphen;unaware types&period;
| xref:BSLSTL_OPTIONAL_USES_STD_ALIASES.adoc[`BSLSTL&lowbar;OPTIONAL&lowbar;USES&lowbar;STD&lowbar;ALIASES`] 
| The following macro `BSLSTL&lowbar;OPTIONAL&lowbar;USES&lowbar;STD&lowbar;ALIASES` controls whether platform standard library is used as a basis for `bsl` types in the following ways&colon; &hyphen; `bsl&colon;&colon;nullopt` is an alias to `std&colon;&colon;nullopt`
| xref:BSLSTL_STRINGVIEWLIKEPARAM_ENABLE_IF_T.adoc[`BSLSTL&lowbar;STRINGVIEWLIKEPARAM&lowbar;ENABLE&lowbar;IF&lowbar;T`] 
| Expand to an `enable&lowbar;if` type alias for `ResultType` that is defined (i&period;e&period;, SFINAE&hyphen;friendly) only when the `STRING&lowbar;VIEW&lowbar;LIKE&lowbar;TYPE` template parameter is convertible to `bsl&colon;&colon;basic&lowbar;string&lowbar;view&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS&gt;`&period; The `CHAR&lowbar;TYPE` and `CHAR&lowbar;TRAITS` template parameters must be in scope&period; The specified `ResultType` (passed as a variadic argument) is the resulting type when the condition is satisfied&period;
| xref:BSLSTL_STRINGVIEWLIKEPARAM_ONLY_ENABLE_IF_T.adoc[`BSLSTL&lowbar;STRINGVIEWLIKEPARAM&lowbar;ONLY&lowbar;ENABLE&lowbar;IF&lowbar;T`] 
| Expand to an `enable&lowbar;if` type alias for `ResultType` that is defined (i&period;e&period;, SFINAE&hyphen;friendly) only when the `STRING&lowbar;VIEW&lowbar;LIKE&lowbar;TYPE` template parameter is convertible to `bsl&colon;&colon;basic&lowbar;string&lowbar;view&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS&gt;` but is _not_ convertible to `const CHAR&lowbar;TYPE &ast;`&period; The `CHAR&lowbar;TYPE` and `CHAR&lowbar;TRAITS` template parameters must be in scope&period; The specified `ResultType` (passed as a variadic argument) is the resulting type when both conditions are satisfied&period;
| xref:BSLSTL_STRINGVIEWLIKEPARAM_TYPE_IF_COMPLETE.adoc[`BSLSTL&lowbar;STRINGVIEWLIKEPARAM&lowbar;TYPE&lowbar;IF&lowbar;COMPLETE`] 
| We need to use an intermediate completeness test to work around deficiencies with SFINAE in the Sun and AIX compilers&period;
| xref:BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T.adoc[`BSLSTL&lowbar;STRING&lowbar;ONLY&lowbar;STRINGVIEW&lowbar;ENABLE&lowbar;IF&lowbar;T`] 
| SFINAE enable&lowbar;if type alias for types convertible to string&lowbar;view but NOT convertible to C&hyphen;string and NOT an accessible base of `bsl&colon;&colon;basic&lowbar;string` or `std&colon;&colon;basic&lowbar;string`&period; The result type is the macro argument if enabled&period; This is a variadic macro to support result types containing commas (e&period;g&period;, `basic&lowbar;string&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS, ALLOCATOR&gt;`)&period;
| xref:BSLSTL_STRING_VIEW_IS_ALIASED.adoc[`BSLSTL&lowbar;STRING&lowbar;VIEW&lowbar;IS&lowbar;ALIASED`] 
| `BSLSTL&lowbar;STRING&lowbar;VIEW&lowbar;IS&lowbar;ALIASED` is defined when `bsl&colon;&colon;string&lowbar;view` and its accompanying symbols are aliases to their `std` equivalents&period; Note that `std&colon;&colon;string` may coexist with `bsl&colon;&colon;string&lowbar;view` that is _not_ an alias of it&semi; see `BSLSTL&lowbar;STRING&lowbar;VIEW&lowbar;AND&lowbar;STD&lowbar;STRING&lowbar;VIEW&lowbar;COEXIST`&period;
| xref:BSLSTL_VARIANT_CONVERT_INDEX_OF.adoc[`BSLSTL&lowbar;VARIANT&lowbar;CONVERT&lowbar;INDEX&lowbar;OF`] 
| This component&hyphen;private macro expands to the index of the first alternative in the specified `VARIANT` that is a &quot;unique&quot; best match for conversion from `std&colon;&colon;declval&lt;TYPE&gt;()`&period; See the documentation for `Variant&lowbar;ConvertIndex` for more details&period;
| xref:BSLSTL_VARIANT_CONVERT_TYPE_OF.adoc[`BSLSTL&lowbar;VARIANT&lowbar;CONVERT&lowbar;TYPE&lowbar;OF`] 
| This component&hyphen;private macro expands to the type of the alternative in the specified `VARIANT` that is a &quot;unique&quot; best match for conversion from `std&colon;&colon;declval&lt;TYPE&gt;()`&period; See the documentation for `Variant&lowbar;ConvertIndex` for more details&period;
| xref:BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM.adoc[`BSLSTL&lowbar;VARIANT&lowbar;DECLARE&lowbar;IF&lowbar;CONSTRUCTS&lowbar;FROM`] 
| This component&hyphen;private macro is used as a constraint in function declarations which require the specified `VARIANT` to be constructible from the specified `TYPE`&period;
| xref:BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD.adoc[`BSLSTL&lowbar;VARIANT&lowbar;DECLARE&lowbar;IF&lowbar;CONSTRUCTS&lowbar;FROM&lowbar;STD`] 
| This component&hyphen;private macro is used as a constraintwhen declaring constructors of `variant` from the corresponding `std&colon;&colon;variant`&period;
| xref:BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE.adoc[`BSLSTL&lowbar;VARIANT&lowbar;DECLARE&lowbar;IF&lowbar;HAS&lowbar;UNIQUE&lowbar;TYPE`] 
| This component&hyphen;private macro is used as a constraint in function declarations which require the specified `TYPE` to be a unique alternative in `variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;`&period;
| xref:BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM.adoc[`BSLSTL&lowbar;VARIANT&lowbar;DEFINE&lowbar;IF&lowbar;CONSTRUCTS&lowbar;FROM`] 
| This component&hyphen;private macro is used as a constraint in function definitions which require the specified `VARIANT` to be constructible from the specified `TYPE`&period;
| xref:BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM_STD.adoc[`BSLSTL&lowbar;VARIANT&lowbar;DEFINE&lowbar;IF&lowbar;CONSTRUCTS&lowbar;FROM&lowbar;STD`] 
| This component&hyphen;private macro is used as a constraint when defining constructors of `variant` from the corresponding `std&colon;&colon;variant`&period;
| xref:BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE.adoc[`BSLSTL&lowbar;VARIANT&lowbar;DEFINE&lowbar;IF&lowbar;HAS&lowbar;UNIQUE&lowbar;TYPE`] 
| This component&hyphen;private macro is used as a constraint in function definitions which require the specified `TYPE` to be a unique alternative in `variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;`&period; Implementation note&colon; This macro can&apos;t use `BSLSTL&lowbar;VARIANT&lowbar;HAS&lowbar;UNIQUE&lowbar;TYPE` because this macro is used at points where `variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;` expands to an invalid construct&period;
| xref:BSLSTL_VARIANT_HAS_UNIQUE_TYPE.adoc[`BSLSTL&lowbar;VARIANT&lowbar;HAS&lowbar;UNIQUE&lowbar;TYPE`] 
| This component&hyphen;private macro expands to the check for whether the specified `TYPE` is a unique alternative in `variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;`&period; See definition `Variant&lowbar;HasUniqueType` for more details&period;
| xref:BSLSTL_VARIANT_INDEX_OF.adoc[`BSLSTL&lowbar;VARIANT&lowbar;INDEX&lowbar;OF`] 
| This component&hyphen;private macro expands to the index of the first alternative in the specified `VARIANT` that is identical to the specified `TYPE`, or `bsl&colon;&colon;variant&lowbar;npos` if no such alternative exists&period;
| xref:BSLSTL_VARIANT_TYPE_AT_INDEX.adoc[`BSLSTL&lowbar;VARIANT&lowbar;TYPE&lowbar;AT&lowbar;INDEX`] 
| This component&hyphen;private macro expands to the type of alternative at specified `INDEX` for a variant of type `bsl&colon;&colon;variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;`&period;
| xref:BSLSTL_VARIANT_VISITID.adoc[`BSLSTL&lowbar;VARIANT&lowbar;VISITID`] 
| This component&hyphen;private macro expands to the invocation of `Variant&lowbar;ImpUtil&colon;&colon;visitId` with specified `RET` as return type, and specified `VISITOR` and specified `VAROBJ` as arguments&period; See the documentation of `Variant&lowbar;ImpUtil&colon;&colon;visitId` for more details&period;
| xref:BSLS_BSLONCE_INITIALIZER.adoc[`BSLS&lowbar;BSLONCE&lowbar;INITIALIZER`] 
| Use this macro to initialize an object of type `bsls&colon;&colon;Once`&period; E&period;g&period;&colon; &grave; bsls&colon;&colon;Once once &equals; BSLS&lowbar;BSLONCE&lowbar;INITIALIZER&semi; &grave; Note that we use an unlikely arbitrary value to permit effectively asserting a `BslOnce` for correct initialization&period;
| xref:BSLS_BSLTESTUTIL_L_.adoc[`BSLS&lowbar;BSLTESTUTIL&lowbar;L&lowbar;`] 
| Current line number&period;
| xref:BSLS_BSLTESTUTIL_P.adoc[`BSLS&lowbar;BSLTESTUTIL&lowbar;P`] 
| Print identifier and its value&period;
| xref:BSLS_BSLTESTUTIL_P_.adoc[`BSLS&lowbar;BSLTESTUTIL&lowbar;P&lowbar;`] 
| P(X) without &grave;
&grave;&period;
| xref:BSLS_BSLTESTUTIL_Q.adoc[`BSLS&lowbar;BSLTESTUTIL&lowbar;Q`] 
| Quote identifier literally&period;
| xref:BSLS_BSLTESTUTIL_T_.adoc[`BSLS&lowbar;BSLTESTUTIL&lowbar;T&lowbar;`] 
| Print a tab (w&sol;o newline)&period;
| xref:BSLS_DEPRECATE_CAT.adoc[`BSLS&lowbar;DEPRECATE&lowbar;CAT`] 
| Expand to the expansion of the specified `X`, joined to the expansion of the specified `Y`&period;
| xref:BSLS_DEPRECATE_CAT_B.adoc[`BSLS&lowbar;DEPRECATE&lowbar;CAT&lowbar;B`] 
| Internal implementation machinery for `BSLS&lowbar;DEPRECATE&lowbar;CAT`&period;
| xref:BSLS_DEPRECATE_ISDEFINED.adoc[`BSLS&lowbar;DEPRECATE&lowbar;ISDEFINED`] 
| Expand to an expression evaluating to `true` in a preprocessor context if the deprecation control macro symbol supplied as an argument has been `&num;define`d as nil, 0, or 1, and expand to an expression evaluating to `false` otherwise&period; The behavior is undefined unless this macro is evaluated with a single argument having the form of a deprecation control macro symbol, and that symbol has either not been `&num;define`d at all or has been `&num;define`d as nil, 0, or 1&period;
| xref:BSLS_DEPRECATE_ISDEFINED_A.adoc[`BSLS&lowbar;DEPRECATE&lowbar;ISDEFINED&lowbar;A`] 
| Internal implementation machinery for `BSLS&lowbar;DEPRECATE&lowbar;ISDEFINED`&period;
| xref:BSLS_DEPRECATE_ISNONZERO.adoc[`BSLS&lowbar;DEPRECATE&lowbar;ISNONZERO`] 
| Expand to an expression evaluating to `true` in a preprocessor context if the deprecation control macro symbol supplied as an argument has been `&num;define`d as an expression that evaluates to a non&hyphen;zero value, and expand to an expression evaluating to `false` otherwise&period; The behavior is undefined unless this macro is evaluated with a single argument having the form of a deprecation control macro symbol, and that symbol has either not been `&num;define`d at all, or has been `&num;define`d as nil or an arithmetic expression&period;
| xref:BSLS_DEPRECATE_ISNONZERO_A.adoc[`BSLS&lowbar;DEPRECATE&lowbar;ISNONZERO&lowbar;A`] 
| Internal implementation machinery for `BSLS&lowbar;DEPRECATE&lowbar;ISNONZERO`&period;
| xref:BSLS_DEPRECATE_ISPASTTHRESHOLD.adoc[`BSLS&lowbar;DEPRECATE&lowbar;ISPASTTHRESHOLD`] 
| Expand to an expression evaluating to `true` in a preprocessor context if the specified version `M&period;N` of the specified UOR `U` is past the deprecation threshold for `U`, and expand to an expression evaluating to `false` otherwise&period; Version `M&period;N` of `U` is past the deprecation threshold for `U` if&colon; &ast; An explicit deprecation threshold has been defined for UOR `U` and that threshold is greater than or equal to version `M&period;N`, or &ast; An explicit deprecation threshold has _not_ been defined for UOR `U`, the versioning package for UOR `U` defines `&lt;U&gt;&lowbar;VERSION&lowbar;MAJOR` and `&lt;U&gt;&lowbar;VERSION&lowbar;MINOR`, and the version so designated is greater than version `M&period;N`&period;
| xref:BSLS_DEPRECATE_ISPASTTHRESHOLD_A.adoc[`BSLS&lowbar;DEPRECATE&lowbar;ISPASTTHRESHOLD&lowbar;A`] 
| Internal implementation machinery for `BSLS&lowbar;DEPRECATE&lowbar;ISPASTTHRESHOLD`&period;
| xref:BSLS_DEPRECATE_ISRETAINED.adoc[`BSLS&lowbar;DEPRECATE&lowbar;ISRETAINED`] 
| Expand to an expression evaluating to `true` in a preprocessor context if deprecations in the specified version `M&period;N` of the specified UOR `U` have been deactivated in this build by defining either the corresponding `BB&lowbar;SILENCE&lowbar;DEPRECATIONS&lowbar;&lt;U&gt;_&lt;M&gt;_&lt;N&gt;` macro or the corresponding `BB&lowbar;SILENCE&lowbar;DEPRECATIONS&lowbar;FOR&lowbar;BUILDING&lowbar;UOR&lowbar;&lt;U&gt;` macro, and expand to an expression evaluating to `false` otherwise&period;
| xref:BSLS_DEPRECATE_ISRETAINED_B.adoc[`BSLS&lowbar;DEPRECATE&lowbar;ISRETAINED&lowbar;B`] 
| Internal implementation machinery for `BSLS&lowbar;DEPRECATE&lowbar;ISRETAINED`&period;
| xref:BSLS_DEPRECATE_IS_ACTIVE.adoc[`BSLS&lowbar;DEPRECATE&lowbar;IS&lowbar;ACTIVE`] 
| Expand to an expression evaluating to `true` in a preprocessor context if deprecations are being enforced for the specified version `M&period;N` of the specified UOR `U`, and expand to an expression evaluating to `false` otherwise&period; Deprecations will be enforced for version `M&period;N` of UOR `U` if&colon; &ast; `BB&lowbar;SILENCE&lowbar;DEPRECATIONS&lowbar;&lt;U&gt;_&lt;M&gt;_&lt;N&gt;` has not been defined in this translation unit, and &ast; `BB&lowbar;SILENCE&lowbar;DEPRECATIONS&lowbar;FOR&lowbar;BUILDING&lowbar;UOR&lowbar;&lt;U&gt;` has not been defined in this translation unit, and &ast; One of the following holds true&colon; &hyphen; `BB&lowbar;WARN&lowbar;ALL&lowbar;DEPRECATIONS&lowbar;FOR&lowbar;TESTING&lowbar;ONLY` has been defined, or &hyphen; An explicit deprecation threshold has been defined for UOR `U` and that threshold is greater than or equal to version `M&period;N`, or &hyphen; An explicit deprecation threshold has _not_ been defined for UOR `U`, the versioning package for UOR `U` defines `&lt;U&gt;&lowbar;VERSION&lowbar;MAJOR` and `&lt;U&gt;&lowbar;VERSION&lowbar;MINOR`, and the version so designated is greater than version `M&period;N`&period;
| xref:BSLS_DEPRECATE_MAKE_VER.adoc[`BSLS&lowbar;DEPRECATE&lowbar;MAKE&lowbar;VER`] 
| Expand to an opaque sequence of symbols encoding a UOR version where the specified `M` is the major version number and the specified `N` is the minor version number&period;
| xref:BSLS_EXCEPTION_SPEC.adoc[`BSLS&lowbar;EXCEPTION&lowbar;SPEC`] 
| DEPRECATED&colon; This macro is deprecated, and cannot expand to a supported syntax on the current platform&period;
| xref:BSLS_EXCEPTION_VIRTUAL_NOTHROW.adoc[`BSLS&lowbar;EXCEPTION&lowbar;VIRTUAL&lowbar;NOTHROW`] 
| The exception specification that overrides of the virtual destructor and the `exception&colon;&colon;what()` virtual method should use&period; It is a separate macro from `BSLS&lowbar;NOTHROW&lowbar;SPEC` because the GNU library unconditionally declares the function `throw()`, regardless if exceptions are enabled or not &hyphen; and overrides must do the same&period;
| xref:BSLS_EXCEPTION_WHAT_NOTHROW.adoc[`BSLS&lowbar;EXCEPTION&lowbar;WHAT&lowbar;NOTHROW`] 
| More specialized name for the no&hyphen;throw declaration of the `exception&colon;&colon;what()` method&period; Use `BSLS&lowbar;EXCEPTION&lowbar;VIRTUAL&lowbar;NOTHROW` instead&period;
| xref:BSLS_IDENT_RCSID.adoc[`BSLS&lowbar;IDENT&lowbar;RCSID`] 
| `BSLS&lowbar;IDENT&lowbar;RCSID()` &hyphen; insert ident str (specific to platform&sol;compiler)
| xref:BSLS_LIBRARYFEATURES_HAS_C90_GETS.adoc[`BSLS&lowbar;LIBRARYFEATURES&lowbar;HAS&lowbar;C90&lowbar;GETS`] 
| Set unconditionally for compilers supporting an earlier standard than C&plus;&plus;14&semi; this feature macro will be undefined for those platforms with partial support for C&plus;&plus;14, implementing the removal of this dangerous function&period;
| xref:BSLS_LIBRARYFEATURES_HAS_CPP14_INTEGER_SEQUENCE.adoc[`BSLS&lowbar;LIBRARYFEATURES&lowbar;HAS&lowbar;CPP14&lowbar;INTEGER&lowbar;SEQUENCE`] 
| It appears that all standard libraries make this C&plus;&plus;14 feature available even in C&plus;&plus;11 mode as it is so useful when implementing `tuple` features&period;
| xref:BSLS_LIBRARYFEATURES_HAS_CPP17_DEPRECATED_REMOVED.adoc[`BSLS&lowbar;LIBRARYFEATURES&lowbar;HAS&lowbar;CPP17&lowbar;DEPRECATED&lowbar;REMOVED`] 
| These APIs should be removed in C&plus;&plus;17&period; Undefined conditionally later in this file for implementations that still have it&period;
| xref:BSLS_LIBRARYFEATURES_HAS_CPP20_DEPRECATED_REMOVED.adoc[`BSLS&lowbar;LIBRARYFEATURES&lowbar;HAS&lowbar;CPP20&lowbar;DEPRECATED&lowbar;REMOVED`] 
| These APIs should be removed in C&plus;&plus;20&period; Undefined conditionally later in this file for implementations that still have it&period;
| xref:BSLS_LIBRARYFEATURES_HAS_CPP98_AUTO_PTR.adoc[`BSLS&lowbar;LIBRARYFEATURES&lowbar;HAS&lowbar;CPP98&lowbar;AUTO&lowbar;PTR`] 
| Set unconditionally&period; This features is found on each compiler version&sol;platform combination tested&period; Assume universally available until the day tool chains start removing this deprecated class template&period;
| xref:BSLS_MACROINCREMENT.adoc[`BSLS&lowbar;MACROINCREMENT`] 
| Return the preprocessor number that is the successor to `MACRO&lowbar;VALUE`&period; The behavior is undefined unless `MACRO&lowbar;VALUE` is an integer literal, or a macro that ultimately expands to an integer literal&period;
| xref:BSLS_MACROINCREMENT_IMPL.adoc[`BSLS&lowbar;MACROINCREMENT&lowbar;IMPL`] 
| The `BSLS&lowbar;MACROINCREMENT&lowbar;IMPL` macro is an implementation detail that forces the token&hyphen;pasting to occur in a separate round of macro expansion, so that the computed macro will, in turn, expand to the desired literal&period;
| xref:BSLS_MACROREPEAT.adoc[`BSLS&lowbar;MACROREPEAT`] 
| Expand to `N` invocations of `MACRO(x)`, where `x` in each invocation is the next number in the sequence from `1` to `N`&period; If `N` is `0`, then the expansion is empty&period; For example `BSLS&lowbar;MACROREPEAT(3, XYZ)` expands to `XYZ(1) XYZ(2) XYZ(3)`&period; The behavior is undefined unless `N` is a decimal integer (or is a macro that expands to a decimal integer) in the range 0 to 20&period; Note that `MACRO` is typically a macro with one argument, but may also be a function or functor&period;
| xref:BSLS_MACROREPEAT_COMMA.adoc[`BSLS&lowbar;MACROREPEAT&lowbar;COMMA`] 
| Expand to `N` comma&hyphen;separated invocations of `MACRO(x)`, where `x` in each invocation is the next number in the sequence from `1` to `N`&period; If `N` is `0`, then the expansion is empty&period; For example `BSLS&lowbar;MACROREPEAT&lowbar;COMMA(3, XYZ)` expands to `XYZ(1), XYZ(2), XYZ(3)`&period; The behavior is undefined unless `N` is a decimal integer (or is a macro that expands to a decimal integer) in the range 0 to 20&period; Note that `MACRO` is typically a macro with one argument, but may also be a function or functor&period;
| xref:BSLS_MACROREPEAT_SEP.adoc[`BSLS&lowbar;MACROREPEAT&lowbar;SEP`] 
| Expand to `N` invocations of `MACRO(x)` separated by the token sequence `S`, where `x` in each invocation is the next number in the sequence from `1` to `N`&period; If `N` is `0`, then the expansion is empty&period; For example `BSLS&lowbar;MACROREPEAT&lowbar;SEP(3, XYZ, &semi;)` expands to &apos;XYZ(1) &semi; XYZ(2) &semi; XYZ(3)`&period; The behavior is undefined unless `N&apos; is a decimal integer (or is a macro that expands to a decimal integer) in the range 0 to 20&period; Note that `MACRO` is typically a macro with one argument, but may also be a function or functor&period;
| xref:BSLS_PLATFORMUTIL_IS_LITTLE_ENDIAN.adoc[`BSLS&lowbar;PLATFORMUTIL&lowbar;IS&lowbar;LITTLE&lowbar;ENDIAN`] 
| DEPRECATED&colon; Use preprocessor macro `BSLS&lowbar;PLATFORM&lowbar;IS&lowbar;LITTLE&lowbar;ENDIAN` defined in `bsls&lowbar;platform` instead&period;
| xref:BSLS_PLATFORM_CMP_VER_MAJOR.adoc[`BSLS&lowbar;PLATFORM&lowbar;CMP&lowbar;VER&lowbar;MAJOR`] 
| This deprecated macro is defined for backwards compatibility only&period;
| xref:BSLTF_TEMPLATETESTFACILITY_TEST_TYPES_ALL.adoc[`BSLTF&lowbar;TEMPLATETESTFACILITY&lowbar;TEST&lowbar;TYPES&lowbar;ALL`] 
| This macro refers to all of the test types defined in this package&period; Note that the macro can be used as the last argument to the `BSLTF&lowbar;TEMPLATETESTFACILITY&lowbar;RUN&lowbar;EACH&lowbar;TYPE` macro&period;
| xref:BSLTF_TEMPLATETESTFACILITY_TEST_TYPES_PRIMITIVE.adoc[`BSLTF&lowbar;TEMPLATETESTFACILITY&lowbar;TEST&lowbar;TYPES&lowbar;PRIMITIVE`] 
| This macro refers to all of the primitive test types defined in this package&period; Note that it can be used as the last argument to the `BSLTF&lowbar;TEMPLATETESTFACILITY&lowbar;RUN&lowbar;EACH&lowbar;TYPE` macro&period;
| xref:BSLTF_TEMPLATETESTFACILITY_TEST_TYPES_REGULAR.adoc[`BSLTF&lowbar;TEMPLATETESTFACILITY&lowbar;TEST&lowbar;TYPES&lowbar;REGULAR`] 
| This macro refers to all of the regular test types defined in this package&period; Note that the macro can be used as the last argument to the `BSLTF&lowbar;TEMPLATETESTFACILITY&lowbar;RUN&lowbar;EACH&lowbar;TYPE` macro&period;
| xref:BSLTF_TEMPLATETESTFACILITY_TEST_TYPES_USER_DEFINED.adoc[`BSLTF&lowbar;TEMPLATETESTFACILITY&lowbar;TEST&lowbar;TYPES&lowbar;USER&lowbar;DEFINED`] 
| This macro refers to all of the user&hyphen;defined test types defined in this package&period; Note that the macro can be used as the last argument to the `BSLTF&lowbar;TEMPLATETESTFACILITY&lowbar;RUN&lowbar;EACH&lowbar;TYPE` macro&period;
| xref:BSL_GET_VERSION_MAJOR.adoc[`BSL&lowbar;GET&lowbar;VERSION&lowbar;MAJOR`] 
| Extract from the specified `version` the corresponding major version&period; `version` is the result of a `BSL&lowbar;MAKE&lowbar;VERSION(major, minor)` invocation, and this macro returns `major`&period;
| xref:BSL_GET_VERSION_MINOR.adoc[`BSL&lowbar;GET&lowbar;VERSION&lowbar;MINOR`] 
| Extract from the specified `version` the corresponding minor version&period; `version` is the result of a `BSL&lowbar;MAKE&lowbar;VERSION(major, minor)` invocation, and this macro returns `minor`&period;
| xref:BSL_MAKE_VERSION.adoc[`BSL&lowbar;MAKE&lowbar;VERSION`] 
| Construct a composite version number from the specified `major` and `minor` version numbers&period; The result is unique for each combination of `major` and `minor`, and is sortable such that a value composed from a given `major` version number will compare larger than a value composed from a smaller `major` version number (and similarly for `minor` version numbers)&period; Note that if `major` and `minor` are both compile&hyphen;time integral constants, then the resulting expression is also a compile&hyphen;time integral constant&period; Also note that the patch version number is intentionally not included&period; The behavior is undefined unless `major` is an integral value in the range `&lsqb;0 &period;&period; 99&rsqb;` and `minor` is an integral value in the range `&lsqb;0 &period;&period; 9999&rsqb;`&period;
| xref:BSL_VERSION.adoc[`BSL&lowbar;VERSION`] 
| Construct an integer (unique to the specified `BSL&lowbar;VERSION&lowbar;MAJOR` and `BSL&lowbar;VERSION&lowbar;MINOR` numbers) corresponding to the major and minor version numbers, respectively, of the current (latest) BSL release&period; Note that the patch version number is intentionally not included&period;
| xref:BSL_VERSION_DEPRECATION_THRESHOLD.adoc[`BSL&lowbar;VERSION&lowbar;DEPRECATION&lowbar;THRESHOLD`] 
| Declare that deprecations for this UOR introduced in the specified version or earlier will be &quot;active&quot; by default &hyphen;&hyphen; i&period;e&period;, `BSLS&lowbar;DEPRECATE&lowbar;IS&lowbar;ACTIVE` will be `true` (which typically enables deprecation warnings)&period; Note that we define this macro in this special component, so that it is available at the lowest level in the component hierarchy of this UOR&period;
| xref:BSL_VERSION_MAJOR.adoc[`BSL&lowbar;VERSION&lowbar;MAJOR`] 
| Provide the major version number of the current (latest) BSL release&period;
| xref:BSL_VERSION_MINOR.adoc[`BSL&lowbar;VERSION&lowbar;MINOR`] 
| Provide the minor version number of the current (latest) BSL release&period;
| xref:bdealg_HasTrait.adoc[`bdealg&lowbar;HasTrait`] 
| This alias is defined for backward compatibility&period;
| xref:bdealg_SelectTrait.adoc[`bdealg&lowbar;SelectTrait`] 
| This alias is defined for backward compatibility&period;
| xref:bdema_Allocator.adoc[`bdema&lowbar;Allocator`] 
| This alias is defined for backward compatibility&period;
| xref:bdes_ObjectBuffer.adoc[`bdes&lowbar;ObjectBuffer`] 
| This alias is defined for backward compatibility&period;
| xref:bslalg_AutoArrayDestructor.adoc[`bslalg&lowbar;AutoArrayDestructor`] 
| This alias is defined for backward compatibility&period;
| xref:bslalg_AutoArrayMoveDestructor.adoc[`bslalg&lowbar;AutoArrayMoveDestructor`] 
| This alias is defined for backward compatibility&period;
| xref:bslalg_AutoScalarDestructor.adoc[`bslalg&lowbar;AutoScalarDestructor`] 
| This alias is defined for backward compatibility&period;
| xref:bslalg_ConstructorProxy.adoc[`bslalg&lowbar;ConstructorProxy`] 
| This alias is defined for backward compatibility&period;
| xref:bslalg_DequeImpUtil.adoc[`bslalg&lowbar;DequeImpUtil`] 
| This alias is defined for backward compatibility&period;
| xref:bslalg_DequeIterator.adoc[`bslalg&lowbar;DequeIterator`] 
| This alias is defined for backward compatibility&period;
| xref:bslalg_HasTrait.adoc[`bslalg&lowbar;HasTrait`] 
| This alias is defined for backward compatibility&period;
| xref:bslalg_SelectTrait.adoc[`bslalg&lowbar;SelectTrait`] 
| This alias is defined for backward compatibility&period;
| xref:bslalg_TypeTraitNil.adoc[`bslalg&lowbar;TypeTraitNil`] 
| This alias is defined for backward compatibility&period;
| xref:bslma_AutoDeallocator.adoc[`bslma&lowbar;AutoDeallocator`] 
| This alias is defined for backward compatibility&period;
| xref:bslma_AutoDestructor.adoc[`bslma&lowbar;AutoDestructor`] 
| This alias is defined for backward compatibility&period;
| xref:bslma_AutoRawDeleter.adoc[`bslma&lowbar;AutoRawDeleter`] 
| This alias is defined for backward compatibility&period;
| xref:bslma_DeallocatorGuard.adoc[`bslma&lowbar;DeallocatorGuard`] 
| This alias is defined for backward compatibility&period;
| xref:bslma_DeallocatorProctor.adoc[`bslma&lowbar;DeallocatorProctor`] 
| This alias is defined for backward compatibility&period;
| xref:bslma_DestructorGuard.adoc[`bslma&lowbar;DestructorGuard`] 
| This alias is defined for backward compatibility&period;
| xref:bslma_DestructorProctor.adoc[`bslma&lowbar;DestructorProctor`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_AddReference.adoc[`bslmf&lowbar;AddReference`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_ArrayToConstPointer.adoc[`bslmf&lowbar;ArrayToConstPointer`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_ArrayToPointer.adoc[`bslmf&lowbar;ArrayToPointer`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_ConstForwardingType.adoc[`bslmf&lowbar;ConstForwardingType`] 
| DEPRECATED&colon; This alias is defined for backward compatibility&period;
| xref:bslmf_EnableIf.adoc[`bslmf&lowbar;EnableIf`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_ForwardingType.adoc[`bslmf&lowbar;ForwardingType`] 
| DEPRECATED&colon; This alias is defined for backward compatibility&period;
| xref:bslmf_FunctionPointerTraits.adoc[`bslmf&lowbar;FunctionPointerTraits`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_If.adoc[`bslmf&lowbar;If`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsArray.adoc[`bslmf&lowbar;IsArray`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsClass.adoc[`bslmf&lowbar;IsClass`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsConvertible.adoc[`bslmf&lowbar;IsConvertible`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsEnum.adoc[`bslmf&lowbar;IsEnum`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsFunctionPointer.adoc[`bslmf&lowbar;IsFunctionPointer`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsFundamental.adoc[`bslmf&lowbar;IsFundamental`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsMemberFunctionPointer.adoc[`bslmf&lowbar;IsMemberFunctionPointer`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsNil.adoc[`bslmf&lowbar;IsNil`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsPointer.adoc[`bslmf&lowbar;IsPointer`] 
| This alias is defined for backward&hyphen;compatibility&period;
| xref:bslmf_IsPolymorphic.adoc[`bslmf&lowbar;IsPolymorphic`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_IsSame.adoc[`bslmf&lowbar;IsSame`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_MemberFunctionPointerTraits.adoc[`bslmf&lowbar;MemberFunctionPointerTraits`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_MemberFunctionPointerTraitsImp.adoc[`bslmf&lowbar;MemberFunctionPointerTraitsImp`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_MetaInt.adoc[`bslmf&lowbar;MetaInt`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_RemoveCvq.adoc[`bslmf&lowbar;RemoveCvq`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_RemoveReference.adoc[`bslmf&lowbar;RemoveReference`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Switch.adoc[`bslmf&lowbar;Switch`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Switch2.adoc[`bslmf&lowbar;Switch2`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Switch3.adoc[`bslmf&lowbar;Switch3`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Switch4.adoc[`bslmf&lowbar;Switch4`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Switch5.adoc[`bslmf&lowbar;Switch5`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Switch6.adoc[`bslmf&lowbar;Switch6`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Switch7.adoc[`bslmf&lowbar;Switch7`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Switch8.adoc[`bslmf&lowbar;Switch8`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Switch9.adoc[`bslmf&lowbar;Switch9`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_Tag.adoc[`bslmf&lowbar;Tag`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList.adoc[`bslmf&lowbar;TypeList`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList1.adoc[`bslmf&lowbar;TypeList1`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList10.adoc[`bslmf&lowbar;TypeList10`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList11.adoc[`bslmf&lowbar;TypeList11`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList12.adoc[`bslmf&lowbar;TypeList12`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList13.adoc[`bslmf&lowbar;TypeList13`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList14.adoc[`bslmf&lowbar;TypeList14`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList15.adoc[`bslmf&lowbar;TypeList15`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList16.adoc[`bslmf&lowbar;TypeList16`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList17.adoc[`bslmf&lowbar;TypeList17`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList18.adoc[`bslmf&lowbar;TypeList18`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList19.adoc[`bslmf&lowbar;TypeList19`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList2.adoc[`bslmf&lowbar;TypeList2`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList20.adoc[`bslmf&lowbar;TypeList20`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList3.adoc[`bslmf&lowbar;TypeList3`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList4.adoc[`bslmf&lowbar;TypeList4`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList5.adoc[`bslmf&lowbar;TypeList5`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList6.adoc[`bslmf&lowbar;TypeList6`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList7.adoc[`bslmf&lowbar;TypeList7`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList8.adoc[`bslmf&lowbar;TypeList8`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeList9.adoc[`bslmf&lowbar;TypeList9`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeListNil.adoc[`bslmf&lowbar;TypeListNil`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeListTypeOf.adoc[`bslmf&lowbar;TypeListTypeOf`] 
| This alias is defined for backward compatibility&period;
| xref:bslmf_TypeRep.adoc[`bslmf&lowbar;TypeRep`] 
| This alias is defined for backward compatibility&period;
| xref:bsls_AlignedBuffer.adoc[`bsls&lowbar;AlignedBuffer`] 
| This alias is defined for backward compatibility&period;
| xref:bsls_AlignmentFromType.adoc[`bsls&lowbar;AlignmentFromType`] 
| This alias is defined for backward compatibility&period;
| xref:bsls_ObjectBuffer.adoc[`bsls&lowbar;ObjectBuffer`] 
| This alias is defined for backward compatibility&period;
| xref:bsls_ProtocolTest.adoc[`bsls&lowbar;ProtocolTest`] 
| This alias is defined for backward compatibility&period;
| xref:bsls_ProtocolTestImp.adoc[`bsls&lowbar;ProtocolTestImp`] 
| This alias is defined for backward compatibility&period;
| xref:bsls_UnspecifiedBool.adoc[`bsls&lowbar;UnspecifiedBool`] 
| This alias is defined for backward compatibility&period;
| xref:bslstl_ForwardIterator.adoc[`bslstl&lowbar;ForwardIterator`] 
| This alias is defined for backward compatibility&period;
| xref:bslstl_RandomAccessIterator.adoc[`bslstl&lowbar;RandomAccessIterator`] 
| This alias is defined for backward compatibility&period;
| xref:bslstl_StringRef.adoc[`bslstl&lowbar;StringRef`] 
| This alias is defined for backward compatibility&period;
| xref:bslstl_StringRefData.adoc[`bslstl&lowbar;StringRefData`] 
| This alias is defined for backward compatibility&period;
| xref:bslstl_StringRefImp.adoc[`bslstl&lowbar;StringRefImp`] 
| This alias is defined for backward compatibility&period;
| xref:bslstl_StringRefWide.adoc[`bslstl&lowbar;StringRefWide`] 
| This alias is defined for backward compatibility&period;
|===


== Using Namespace Directives

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP.adoc[`BloombergLP`] 
| The History&hyphen; &hyphen; &hyphen; &hyphen; &hyphen; &hyphen;
|===



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