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

Bloomberg meta&hyphen;function implementations used by `bsl&colon;&colon;is&lowbar;same`&period;

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/AddPointer_Compute.adoc[`AddPointer&lowbar;Compute`] 
| This utility `struct` is a private implementation detail that hosts an overloaded pair of functions that, through SFINAE, can determine whether it is legal to form a pointer to a specified `t&lowbar;TYPE`&period;
| xref:BloombergLP/bslmf/AddReference.adoc[`AddReference`] 
| This meta&hyphen;function class defines a typedef, `Type`, that is an alias for a reference to the parameterized `t&lowbar;TYPE`&period; References to cv&hyphen;qualified `void` will produce the original `void` type and not a reference (see specializations below)&period; References&hyphen;to&hyphen;references &quot;collapse&quot; to produce an alias to the original reference type, which is the revised rule according to the C&plus;&plus;11 standard&period; Note that there is no requirement that the parameterized `t&lowbar;TYPE` be a complete type&period;
| xref:BloombergLP/bslmf/ArrayToConstPointer-0f2.adoc[`ArrayToConstPointer`] 
| Meta&hyphen;function mapping an array type to a const pointer type&period;
| xref:BloombergLP/bslmf/ArrayToPointer-0e.adoc[`ArrayToPointer`] 
| Meta&hyphen;function mapping an array type to a pointer type&period;
| xref:BloombergLP/bslmf/ConstForwardingType.adoc[`ConstForwardingType`] 
| DEPRECATED&colon; Use `ForwardingType` instead&period;
| xref:BloombergLP/bslmf/DetectNestedTrait-00.adoc[`DetectNestedTrait`] 
| This `struct` template metafunction detects whether the specified `t&lowbar;TRAIT` parameter is associated with the specified `t&lowbar;TYPE` parameter using the nested type trait mechanism&period; This trait derives from `bsl&colon;&colon;true&lowbar;type` if and only if `t&lowbar;TYPE` is a class type that associated with the specified trait using the `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION` macro, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; Users should not specialize this trait directly for their types, but should always use the macro to make a nested trait association&period;
| xref:BloombergLP/bslmf/EnableIf-0e4.adoc[`EnableIf`] 
| This `struct` template implements a meta&hyphen;function that provides a `typedef` `type` that is an alias to the (template parameter) `t&lowbar;TYPE` if the (template parameter) `t&lowbar;COND` is `true`&semi; otherwise, `type` is not provided&period; If `t&lowbar;TYPE` is not specified, it is set to `void`&period; Note that this generic default template provides `type` for when `t&lowbar;COND` is `true`&semi; a template specialization is provided (below) that omits `type` for when `t&lowbar;COND` is `false`&period;
| xref:BloombergLP/bslmf/FloatingTypeStructuralTraits-03.adoc[`FloatingTypeStructuralTraits`] 
| This is the primary template declaration for `bslmf&colon;&colon;FloatingTypeStructuralTraits`, which is never defined&period;
| xref:BloombergLP/bslmf/ForwardingRefType.adoc[`ForwardingRefType`] 
| This template metafunction has a member `Type` computed such that, for a specified `t&lowbar;TYPE` parameter, a function with argument of `t&lowbar;TYPE` can be called efficiently from another function (e&period;g&period;, a wrapper) by declaring the corresponding parameter of the other wrapper as &apos;typename ForwardingRefType&lt;t&lowbar;TYPE&gt;&colon;&colon;Type&apos;&period; The `Type` member is computed to minimize the number of expensive copies while forwarding the arguments as faithfully as possible&period;
| xref:BloombergLP/bslmf/ForwardingRefTypeUtil.adoc[`ForwardingRefTypeUtil`] 
| Provide a namespace for the `forwardToTarget` function&period;
| xref:BloombergLP/bslmf/ForwardingRefType_Category.adoc[`ForwardingRefType&lowbar;Category`] 
| This component&hyphen;private struct provides a namespace for the type dispatch category enumeration values&period;
| xref:BloombergLP/bslmf/ForwardingRefType_Dispatch.adoc[`ForwardingRefType&lowbar;Dispatch`] 
| This component&hyphen;private class template is a metafunction whose `value` member is the forwarding category for the specified `t&lowbar;TYPE`&period;
| xref:BloombergLP/bslmf/ForwardingType-07.adoc[`ForwardingType`] 
| This template metafunction has a member `Type` computed such that, for a specified `t&lowbar;TYPE` parameter, a function with argument of `t&lowbar;TYPE` can be called efficiently from another function (e&period;g&period;, a wrapper) by declaring the corresponding parameter of the other wrapper as &apos;typename ForwardingType&lt;t&lowbar;TYPE&gt;&colon;&colon;Type&apos;&period; The `Type` member is computed to minimize the number of expensive copies while forwarding the arguments as faithfully as possible&period;
| xref:BloombergLP/bslmf/ForwardingTypeUtil.adoc[`ForwardingTypeUtil`] 
| Provide a namespace for the `forwardToTarget` function&period;
| xref:BloombergLP/bslmf/ForwardingType_Category.adoc[`ForwardingType&lowbar;Category`] 
| This component&hyphen;private struct provides a namespace for thpe type dispatch category enumeration values&period;
| xref:BloombergLP/bslmf/ForwardingType_Dispatch.adoc[`ForwardingType&lowbar;Dispatch`] 
| This component&hyphen;private class template is a metafunction whose `value` member is the forwarding category for the specified `t&lowbar;TYPE`&period;
| xref:BloombergLP/bslmf/ForwardingType_Imp-04.adoc[`ForwardingType&lowbar;Imp&lt;Signaler&lowbar;NotArg, 5&gt;`] 
| Rvalue of user type (i&period;e&period;, class or union) is forwarded as a const reference&period;
| xref:BloombergLP/bslmf/FunctionPointerCLinkage.adoc[`FunctionPointerCLinkage`] 
| C function pointer linkage tag&period;
| xref:BloombergLP/bslmf/FunctionPointerCPlusPlusLinkage.adoc[`FunctionPointerCPlusPlusLinkage`] 
| C&plus;&plus; function pointer linkage tag&period;
| xref:BloombergLP/bslmf/FunctionPointerTraits-04.adoc[`FunctionPointerTraits`] 
| This class gives information about the specified `t&lowbar;PROTOTYPE`&period; The general definition gives no information, but specializations for function pointers types define nested types `ResultType`, `ArgumentList`, and `Linkage`&period;
| xref:BloombergLP/bslmf/HasPointerSemantics-064.adoc[`HasPointerSemantics`] 
| Metafunction indicating whether the (template parameter) `t&lowbar;TYPE` has pointer&hyphen;like semantics&period;
| xref:BloombergLP/bslmf/If.adoc[`If`] 
| This meta&hyphen;function selects `t&lowbar;IF&lowbar;TRUE&lowbar;TYPE` if `t&lowbar;CONDITION` is non&hyphen;zero&period; and `t&lowbar;IF&lowbar;FALSE&lowbar;TYPE` otherwise&period;
| xref:BloombergLP/bslmf/IntegerSequence.adoc[`IntegerSequence`] 
| This class template represents a compile&hyphen;time sequence of integers&period; When passed as an argument to a function template, the specified parameter pack `t&lowbar;INTS` can be deduced and used a in pack expansion&period;
| xref:BloombergLP/bslmf/InvokeResultDeductionFailed.adoc[`InvokeResultDeductionFailed`] 
| When `invoke&lowbar;result` cannot deduce the actual return type of a functor (in C&plus;&plus;03 mode), it yields this type as a placeholder&period; The advantage of using this placeholder instead of a compilation failure (e&period;g&period;, using a static assert) is that the return type of an INVOKE() operation is often discarded, so our failure to deduce the return type is often harmless&period; Since `InvokeResultDeductionFailed` is a return type, it must be convertible from the actual return type&semi; this conversion is accomplished by means of a constructor that makes it convertible from _any_ type&period;
| xref:BloombergLP/bslmf/InvokeResult_AddCVRef.adoc[`InvokeResult&lowbar;AddCVRef`] 
| Starting with type, `t&lowbar;UNQUAL&lowbar;TYPE`, generate a new type by applying the following steps in order&colon;
| xref:BloombergLP/bslmf/InvokeResult_BaseCalcUtil.adoc[`InvokeResult&lowbar;BaseCalcUtil`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_FuncPtrImp-0d.adoc[`InvokeResult&lowbar;FuncPtrImp`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_FunctorImp-0e.adoc[`InvokeResult&lowbar;FunctorImp`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_Index.adoc[`InvokeResult&lowbar;Index`] 
| Metafunction helpers for deducing the return type of an expression&period;
| xref:BloombergLP/bslmf/InvokeResult_MemFuncPtrImp-0cf.adoc[`InvokeResult&lowbar;MemFuncPtrImp`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_MemFuncPtrImpDispatch-076.adoc[`InvokeResult&lowbar;MemFuncPtrImpDispatch`] 
| Forward declaration&period;
| xref:BloombergLP/bslmf/InvokeResult_MemObjPtrImp-0d.adoc[`InvokeResult&lowbar;MemObjPtrImp`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_MemObjPtrImpDispatch-0d.adoc[`InvokeResult&lowbar;MemObjPtrImpDispatch`] 
| Forward declaration&period;
| xref:BloombergLP/bslmf/InvokeResult_MemPtrArgQualifiers-0c.adoc[`InvokeResult&lowbar;MemPtrArgQualifiers`] 
| This metafunction determines which cv qualifiers and reference qualifiers should be propagated from the first argument of `invoke&lowbar;result`&period; This primary template is instantiated when `t&lowbar;ARG&lowbar;TYPE` is the same or is derived from `t&lowbar;MEMOF&lowbar;CLASS`&period; The constant `k&lowbar;IS&lowbar;LVALUE` is true iff `t&lowbar;ARG&lowbar;TYPE` is an lvalue reference&semi; the constant `k&lowbar;IS&lowbar;CONST` is true iff `t&lowbar;ARG&lowbar;TYPE` is const&hyphen;qualified&semi; and the constant `k&lowbar;IS&lowbar;VOLATILE` is true iff `t&lowbar;ARG&lowbar;TYPE` is volatile&hyphen;qualified&period;
| xref:BloombergLP/bslmf/InvokeResult_Type-04e.adoc[`InvokeResult&lowbar;Type`] 
| Metafunction to convert a type index back to a type&period; For each specialization of this struct, the `type` member will be the type corresponding to `index`&period; For example, if `index` is `e&lowbar;UCHAR`, then `InvokeResult&lowbar;Type&lt;index&gt;&colon;&colon;type` is `unsigned char`&period;
| xref:BloombergLP/bslmf/InvokeResult_VoidChecker.adoc[`InvokeResult&lowbar;VoidChecker`] 
| Empty type used to detect void expressions&period; The size of this type is the same as `bslmf&colon;&colon;Tag&lt;1&gt;`&period;
| xref:BloombergLP/bslmf/IsAccessibleBaseOf.adoc[`IsAccessibleBaseOf`] 
| This `struct` template provides a type trait to determine if one class is an accessible base class of another class&period; Note that, while similar to `std&colon;&colon;is&lowbar;base&lowbar;of`, when the derived relationship is via private, protected, or ambiguous inheritance `IsAccessibleBaseOf` evaluates to false&period;
| xref:BloombergLP/bslmf/IsArray.adoc[`IsArray`] 
| This `struct` template implements a meta&hyphen;function to determine if the (template parameter) `t&lowbar;TYPE` is an array type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is an array type, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslmf/IsBitwiseCopyable-026.adoc[`IsBitwiseCopyable`] 
| This `struct` template provides a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is bitwise copyable&period;
| xref:BloombergLP/bslmf/IsBitwiseEqualityComparable-018.adoc[`IsBitwiseEqualityComparable`] 
| This trait `struct` is a metafunction that determines whether the specified parameter `t&lowbar;TYPE` is bitwise EqualityComparable&period; If `IsBitwiseEqualityComparable&lt;t&lowbar;TYPE&gt;` is derived from `true&lowbar;type` then `t&lowbar;TYPE` is bitwise EqualityComparable&period; Otherwise, bitwise equality comparability cannot be inferred for `t&lowbar;TYPE`&period; This trait can be associated with a bitwise EqualityComparable user&hyphen;defined class by specializing this class or by using the `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION` macro&period;
| xref:BloombergLP/bslmf/IsBitwiseMoveable-0fb.adoc[`IsBitwiseMoveable`] 
| Trait metafunction that determines whether the specified parameter `t&lowbar;TYPE` is bitwise moveable&period; If `IsBitwiseMoveable&lt;t&lowbar;TYPE&gt;` is derived from `bsl&colon;&colon;true&lowbar;type` then `t&lowbar;TYPE` is bitwise moveable&period; Otherwise, bitwise moveability cannot be inferred for `t&lowbar;TYPE`&period; This trait can be associated with a bitwise moveable user&hyphen;defined class by specializing this class or by using the `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION` macro&period;
| xref:BloombergLP/bslmf/IsBitwiseMoveable_Imp-03.adoc[`IsBitwiseMoveable&lowbar;Imp&lt;allocator&lt;unsigned long&gt;&gt;`] 
| Core implementation of the `IsBitwiseMoveable` trait&period; A class is detected as being bitwise moveable iff it is trivially copyable or it has a nested trait declaration for the `IsBitwiseMoveable` trait&period; In C&plus;&plus;03 however, detection of trivially copyable classes is imperfect and depends on programmer intervention&period; As many empty classes (including standard classes like `std&colon;&colon;less&lt;T&gt;` would not be detected as being trivially copyable and, therefore, bitwise moveable, a heuristic is put in place whereby any type of one byte size is assumed to be bitwise moveable&period; See component&hyphen;level documentation for this component for more details on this heuristic and how to avoid false positives&period;
| xref:BloombergLP/bslmf/IsClass.adoc[`IsClass`] 
| This meta&hyphen;function derives from `bsl&colon;&colon;true&lowbar;type` if the (template parameter) `t&lowbar;TYPE` is a class type, or a reference to a class type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslmf/IsConvertible.adoc[`IsConvertible`] 
| This `struct` template implements a meta&hyphen;function to determine if the (template parameter) `t&lowbar;FROM&lowbar;TYPE` is convertible to the (template parameter) `t&lowbar;TO&lowbar;TYPE`&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;FROM&lowbar;TYPE` is convertible to `t&lowbar;TO&lowbar;TYPE`, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; Note that both `t&lowbar;FROM&lowbar;TYPE` and `t&lowbar;TO&lowbar;TYPE` should be complete types, arrays of unknown bound, or (possibly cv&hyphen;qualified) `void` types&period;
| xref:BloombergLP/bslmf/IsConvertibleToAny.adoc[`IsConvertibleToAny`] 
| This `struct` template implements a meta&hyphen;function to determine if the (template parameter) `t&lowbar;TYPE` is convertible to any other type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if `t&lowbar;TYPE` is convertible to any type, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslmf/IsConvertible_CheckComplete-01b.adoc[`IsConvertible&lowbar;CheckComplete`] 
| Private helper for `IsConvertible` complete&hyphen;type checks&period;
| xref:BloombergLP/bslmf/IsEnum.adoc[`IsEnum`] 
| This `struct` provides a meta&hyphen;function that computes, at compile time, whether the (template parameter) `t&lowbar;TYPE` is an enumerated type&period; It derives from `bsl&colon;&colon;true&lowbar;type` if `t&lowbar;TYPE` is an enumerated type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslmf/IsFunctionPointer.adoc[`IsFunctionPointer`] 
| This template determines if the specified `t&lowbar;PROTOTYPE` is a free (i&period;e&period;, non&hyphen;member) function pointer&period; `value` is defined as 1 if the specified `t&lowbar;PROTOTYPE` is a function pointer type, and a zero value otherwise&period;
| xref:BloombergLP/bslmf/IsFundamental-04.adoc[`IsFundamental`] 
| This `struct` template implements a meta&hyphen;function for checking if a type is fundamental, or a reference to a fundamental type&period; The static constant `value` member will be 1 if `t&lowbar;TYPE` is fundamental and 0 otherwise&period;
| xref:BloombergLP/bslmf/IsFundamental_Imp-0d6.adoc[`IsFundamental&lowbar;Imp&lt;bsl::nullptr&lowbar;t&gt;`] 
| This partial specialization of `IsFundamental&lowbar;Imp` derives from `bsl&colon;&colon;true&lowbar;type` for when the (template parameter) `t&lowbar;TYPE` is `void`&period;
| xref:BloombergLP/bslmf/IsMemberFunctionPointer.adoc[`IsMemberFunctionPointer`] 
| This template determines if the specified `t&lowbar;PROTOTYPE` is a member function pointer&period; `value` is defined as 1 if the specified `t&lowbar;PROTOTYPE` is a member function, and a zero value otherwise&period;
| xref:BloombergLP/bslmf/IsNil-04.adoc[`IsNil`] 
| Metafunction that is `true` for `Nil` and `false` for all other types&period;
| xref:BloombergLP/bslmf/IsPair-08.adoc[`IsPair`] 
| Metafunction that is `false` for all types except `bsl&colon;&colon;pair` specializations&period;
| xref:BloombergLP/bslmf/IsPointer.adoc[`IsPointer`] 
| This `struct` template implements a meta&hyphen;function to determine if the (template parameter) `t&lowbar;TYPE` is a pointer type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is a pointer type (but not a pointer to non&hyphen;static member), and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslmf/IsPolymorphic.adoc[`IsPolymorphic`] 
| This `struct` template implements a meta&hyphen;function to determine if the (template parameter) `t&lowbar;TYPE` is a (possibly cv&hyphen;qualified) polymorphic type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is a polymorphic type, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslmf/IsReferenceWrapper-0e.adoc[`IsReferenceWrapper`] 
| This `struct` template implements a boolean metafunction used to detect if the specified `t&lowbar;TYPE` is a reference wrapper&period; Clients may specialize this `struct` template to inherit from `bsl&colon;&colon;true&lowbar;type` for `t&lowbar;TYPE` types that are specializations of `bsl&colon;&colon;reference&lowbar;wrapper`&period; The behavior is undefined if any other specialization of this `struct` template is defined&period; Note that this `struct` template
| xref:BloombergLP/bslmf/IsSame.adoc[`IsSame`] 
| This `struct` template implements a meta&hyphen;function to determine if the (template parameter) `t&lowbar;TYPE1` and the (template parameter) `t&lowbar;TYPE2` are the same&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if `t&lowbar;TYPE1` and `t&lowbar;TYPE2` are the same, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslmf/IsTransparentPredicate-0f.adoc[`IsTransparentPredicate`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;COMPARATOR` is transparent (has a publicly accessible member that is a type named `is&lowbar;transparent`)&period; This generic default template derives from `bsl&colon;&colon;false&lowbar;type`&period; Template specializations are provided (below) that derive from `bsl&colon;&colon;true&lowbar;type`&period;
| xref:BloombergLP/bslmf/IsTriviallyCopyableCheck.adoc[`IsTriviallyCopyableCheck`] 
| This `struct` exists to return the same value as `is&lowbar;trivially&lowbar;copyable` and is intended to never be specialized&period; The purpose of using it is to perform the following static assert that the `bsl` and `std` versions of `is&lowbar;trivially&lowbar;copyable` are in sync&period;
| xref:BloombergLP/bslmf/IsTriviallyCopyable_DetectTrait-09.adoc[`IsTriviallyCopyable&lowbar;DetectTrait`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (non&hyphen;cv&hyphen;qualified) (template parameter) `t&lowbar;TYPE` has been explicitly tagged with the trivially copyable trait&period; If the flag `t&lowbar;K&lowbar;INTRINSIC` is `true` then the compiler has already determined that `t&lowbar;TYPE` is trivially copyable without user intervention, and the check for nested traits can be optimized away&period;
| xref:BloombergLP/bslmf/IsTriviallyCopyable_Intrinsic.adoc[`IsTriviallyCopyable&lowbar;Intrinsic`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (non&hyphen;cv&hyphen;qualified) (template parameter) `t&lowbar;TYPE` is trivially copyable&period;
| xref:BloombergLP/bslmf/IsTriviallyDefaultConstructible_DetectTrait-0b.adoc[`IsTriviallyDefaultConstructible&lowbar;DetectTrait`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (non&hyphen;cv&hyphen;qualified) (template parameter) `t&lowbar;TYPE` has been explicitly tagged with the trivially default constructible trait&period; If the flag `t&lowbar;K&lowbar;INTRINSIC` is `true` then the compiler has already determined that `t&lowbar;TYPE` is trivially default constructible without user intervention, and the check for nested traits can be optimized away&period;
| xref:BloombergLP/bslmf/IsVoid.adoc[`IsVoid`] 
| This `struct` template implements a meta&hyphen;function to determine if the (template parameter) `t&lowbar;TYPE` is the (possibly cv&hyphen;qualified) `void` type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if `t&lowbar;TYPE` is the `void` type, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_ConcatUtil-0e.adoc[`MakeIntegerSequence&lowbar;ConcatUtil`] 
| This component&hyphen;private class template provides a specialization that concatenates two integer sequences&period; This template is not defined unless the (template parameter) types `t&lowbar;S1` and `t&lowbar;S2` are specializations of the class template `bslmf&colon;&colon;IntegerSequence`&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-0ff.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 0&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an empty integer sequence&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-02.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 1&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 1&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-03.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 2&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 2&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-04.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 3&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 3&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-07.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 4&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 4&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-09.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 5&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 5&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-06.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 6&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 6&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-0b.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 7&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 7&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-00.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 8&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 8&period;
| xref:BloombergLP/bslmf/MatchAnyType.adoc[`MatchAnyType`] 
| Any type can be converted into this type&period;
| xref:BloombergLP/bslmf/MatchArithmeticType.adoc[`MatchArithmeticType`] 
| This copy&hyphen;constructible mechanism can be used as a formal parameter for functions where an arithmetic type can be confused with an iterator type&period; A copy&hyphen;constructible mechanism is needed so that such objects can be used as function arguments&period;
| xref:BloombergLP/bslmf/MemberFunctionPointerTraits.adoc[`MemberFunctionPointerTraits`] 
| This metafunction determines the traits of a member function type, including the type of the object that it is a member of, its result type, and the type of its list of arguments&period;
| xref:BloombergLP/bslmf/MemberFunctionPointerTraits_ClassType.adoc[`MemberFunctionPointerTraits&lowbar;ClassType`] 
| This `class` determines whether the specified `t&lowbar;PROTOTYPE` is a `const`, `volatile` or `noexcept` member function of the specified `t&lowbar;TYPE`&period; The `Type` member will be a correctly const and&sol;or volatile qualified version of `t&lowbar;TYPE`&period; This metafunction is necessary because some old compilers do not correctly dispatch to the correct partial specialization of `MemberFunctionPointerTraits&lowbar;Imp` based on cv&hyphen;qualification of the member&hyphen;function pointer&period;
| xref:BloombergLP/bslmf/MemberFunctionPointerTraits_Imp-09.adoc[`MemberFunctionPointerTraits&lowbar;Imp&lt;t&lowbar;PROTOTYPE, t&lowbar;BSLMF&lowbar;RETURN const volatile(t&lowbar;TYPE::*)(t&lowbar;ARGS&period;&period;&period;) noexcept&gt;`] 
| Specialization to determine the traits of member functions&period; A modern compiler will match only non&hyphen;cv member functions, but some older compilers might match this to any member function&period;
| xref:BloombergLP/bslmf/MemberPointerTraits.adoc[`MemberPointerTraits`] 
| This utility `struct` template provides the following nested typedefs&colon;&colon; `ClassType`&colon; The type of the class for which the specified `t&lowbar;TYPE` is&colon; a pointer to member object&period;&colon; `MemberType`&colon; The type of the member object of the class for which the&colon; specified `t&lowbar;TYPE` is a pointer to member object&period; These typedefs will only be defined if `t&lowbar;TYPE` is a
| xref:BloombergLP/bslmf/MemberPointerTraits_Imp-0d.adoc[`MemberPointerTraits&lowbar;Imp&lt;t&lowbar;MEMBER&lowbar;TYPEt&lowbar;CLASS&lowbar;TYPE::*&gt;`] 
| 
| xref:BloombergLP/bslmf/MetaInt-07.adoc[`MetaInt`] 
| Instantiating this template produces a distinct type for each non&hyphen;negative integer value&period; This template has been deprecated in favor of the standard `integral&lowbar;constant` template&period;
| xref:BloombergLP/bslmf/MovableRefUtil.adoc[`MovableRefUtil`] 
| This `struct` provides a collection of utility functions operating on objects of type `MovableRef&lt;t&lowbar;TYPE&gt;`&period; The primary use of these utilities is to create a consistent notation for using the C&plus;&plus;03 `MovableRef&lt;t&lowbar;TYPE&gt;` objects and the C&plus;&plus;11 `t&lowbar;TYPE&amp;&amp;` r&hyphen;value references&period;
| xref:BloombergLP/bslmf/MovableRefUtil_AddLvalueReference.adoc[`MovableRefUtil&lowbar;AddLvalueReference`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRefUtil_AddMovableReference.adoc[`MovableRefUtil&lowbar;AddMovableReference`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRefUtil_Decay.adoc[`MovableRefUtil&lowbar;Decay`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRefUtil_PropertyTraits.adoc[`MovableRefUtil&lowbar;PropertyTraits`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRefUtil_RemoveReference.adoc[`MovableRefUtil&lowbar;RemoveReference`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRef_Helper.adoc[`MovableRef&lowbar;Helper`] 
| forward declaration
| xref:BloombergLP/bslmf/NestedTraitDeclaration.adoc[`NestedTraitDeclaration`] 
| Class `t&lowbar;TYPE` will be convertible to `NestedTraitDeclaration&lt;t&lowbar;TYPE,t&lowbar;TRAIT,true&gt;` if `t&lowbar;TRAIT` is associated with `t&lowbar;TYPE` using the `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION` macro&period; Nested trait detection depends on `t&lowbar;COND` being true&period; If `t&lowbar;COND` is false, the nested trait detection will not see the conversion it is looking for and will not associate `t&lowbar;TRAIT` with `t&lowbar;TYPE`&period; This feature is used by `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION&lowbar;IF` to turn a trait on or off depending on a compile&hyphen;time condition (usually another trait)&period;
| xref:BloombergLP/bslmf/Nil.adoc[`Nil`] 
| This struct is empty and represents a nil type&period;
| xref:BloombergLP/bslmf/NthParameter-06.adoc[`NthParameter`] 
| Metafunction to compute the specified `t&lowbar;N`th element of the specified `t&lowbar;PARAMS` template parameter pack&period; The `Type` nested typedef will match the `t&lowbar;N`th element of `t&lowbar;PARAMS`, where `t&lowbar;N` is zero&hyphen;based (so that an `t&lowbar;N` of zero corresponds to the first parameter&period;
| xref:BloombergLP/bslmf/NthParameter_Sentinel.adoc[`NthParameter&lowbar;Sentinel`] 
| Sentinel type used internally by `NthParameter` (declared but not defined)&period;
| xref:BloombergLP/bslmf/RemoveCvq.adoc[`RemoveCvq`] 
| This class implements a meta&hyphen;function for stripping top&hyphen;level const&sol;volatile qualifiers from it&apos;s parameter type&period;
| xref:BloombergLP/bslmf/RemoveReference.adoc[`RemoveReference`] 
| This `struct` template implements a meta&hyphen;function to remove the reference&hyphen;ness from the (template parameter) `t&lowbar;TYPE`&period; Note that although this `struct` is functionally equivalent to `bsl&colon;&colon;remove&lowbar;reference`, the use of `bsl&colon;&colon;remove&lowbar;reference` should be preferred&period;
| xref:BloombergLP/bslmf/ResultType-01.adoc[`ResultType`] 
| Metafunction to return the result type of the specified functor type `t&lowbar;FUNC`&period; The nested `type` is identical to `t&lowbar;FUNC&colon;&colon;result&lowbar;type` if such a type exists&semi; otherwise, it is identical to `t&lowbar;FUNC&colon;&colon;ResultType` if that type exists&semi; otherwise, it is identical to the `t&lowbar;FALLBACK` template parameter if it was specified&semi; otherwise, it is undefined&period;
| xref:BloombergLP/bslmf/ResultType_BdeIdiom-0d.adoc[`ResultType&lowbar;BdeIdiom`] 
| Metafunction to detect the BDE `ResultType` idiom as part of the implementation of `bslmf&colon;&colon;ResultType`&period; This `struct` is instantiated when `t&lowbar;FUNC&colon;&colon;result&lowbar;type` doesn&apos;t exist&period; This primary template is matched when `t&lowbar;FUNC&colon;&colon;ResultType` also does not exist&period; The `t&lowbar;FALLBACK` type, if any, is produced&period;
| xref:BloombergLP/bslmf/ResultType_Fallback-0b.adoc[`ResultType&lowbar;Fallback`] 
| Metafunction that defines `type` to be the specified `t&lowbar;FALLBACK` type unless `t&lowbar;FALLBACK` is `bslmf&colon;&colon;Nil`&period;
| xref:BloombergLP/bslmf/SelectTrait.adoc[`SelectTrait`] 
| Instantiate each specified (template parameter) `t&lowbar;TRAIT1` to `t&lowbar;TRAIT9` metafunction using the specified (template parameter) `t&lowbar;TYPE`&period; Inherit from `SelectTraitCase&lt;TRAITx&gt;`, where _x_ is `1` if `t&lowbar;TRAIT1&lt;t&lowbar;TYPE&gt;&colon;&colon;value` is true, `2` if `t&lowbar;TRAIT2&lt;t&lowbar;TYPE&gt;&colon;&colon;value` is true, etc&period;&period; If none of the traits evaluates to true, then inherit from `SelectTraitCase&lt;&gt;`, which means that none of the traits match&period;
| xref:BloombergLP/bslmf/SelectTraitCase.adoc[`SelectTraitCase`] 
| This template expresses a class that is unique for the specified (template parameter) `t&lowbar;TRAIT` metafunction&period; An instantiation of this template is the &quot;compile&hyphen;time return value&quot; of `SelectTrait` (see below)&period; `SelectTraitCase` acts as a sort of compile&hyphen;time pointer&hyphen;to&hyphen;metafunction that holds the identity of a metafunction similar to the way a pointer&hyphen;to&hyphen;function holds (at run&hyphen;time) the identity of a function&period; As in the pointer&hyphen;to&hyphen;function case, a `SelectTraitCase` can also be used indirectly to evaluate `t&lowbar;TRAIT` (at compile time)&period; Also note that, when `SelectTraitCase` is specialized with the default `t&lowbar;TRAIT` type parameter, `SelectTrait&lowbar;False`, it essentially means that none of the traits specified to `SelectTrait` match&period;
| xref:BloombergLP/bslmf/SelectTrait_False.adoc[`SelectTrait&lowbar;False`] 
| Metafunction that always returns false&period;
| xref:BloombergLP/bslmf/Switch-07a1.adoc[`Switch`] 
| This meta&hyphen;function, parameterized by an integral `t&lowbar;SWITCH&lowbar;SELECTOR` and types `t&lowbar;T0` up to `t&lowbar;T9`, provides a single type alias, `Type`, which resolves, through specialization for a particular value `N` of `t&lowbar;SWITCH&lowbar;SELECTOR`, to the type `TN`, or to `Nil` if `t&lowbar;SWITCH&lowbar;SELECTOR` is negative or larger than the number of template arguments provided for the types&period;
| xref:BloombergLP/bslmf/Tag-0b.adoc[`Tag`] 
| This template class is never intended to produce a run&hyphen;time instance&period; The only useful attribute of a tag is its size (which is, of course, computable at compile time, even if an instance is never created)&period; Note that in case of overflow on Linux 64&hyphen;bit machines, we split the size into 2 data members&period;
| xref:BloombergLP/bslmf/TypeList-00d.adoc[`TypeList`] 
| Compile&hyphen;time list of zero or more types&period;
| xref:BloombergLP/bslmf/TypeListTypeAt-03f.adoc[`TypeListTypeAt`] 
| This template is specialized below to return the type the `t&lowbar;INDEX`th member of the typelist `t&lowbar;LIST`&period; If `0 &gt; t&lowbar;INDEX &lt;&equals; t&lowbar;LIST&colon;&colon;LENGTH` then `Type` will be defined as the type of the member&period; Note that t&lowbar;INDEX is relative to 1&period;
| xref:BloombergLP/bslmf/TypeRep.adoc[`TypeRep`] 
| Generate a reference to `t&lowbar;TYPE` for use in meta&hyphen;functions&period;
| xref:BloombergLP/bslmf/UsesAllocatorArgT-0a.adoc[`UsesAllocatorArgT`] 
| User&hyphen;specialized trait type indicating that the constructor of `t&lowbar;TYPE` can be invoked using `bsl&colon;&colon;allocator&lowbar;arg` as its first argument and an allocator object as its second argument&period;
| xref:BloombergLP/bslmf/Util.adoc[`Util`] 
| This struct provides several functions that are specified in the &lt;utility&gt; header of the C&plus;&plus; Standard, in order to support the `bsl` library implementation without cycles into the native standard library, and on platforms with only C&plus;&plus;03 compilers available, where library features may be emulated&period;
| xref:BloombergLP/bslmf/VoidType.adoc[`VoidType`] 
| Metafunction that always yields `type` `void` for any well&hyphen;formed list of type parameters&period; This metafunction is useful when using SFINAE to probe for well&hyphen;formed types&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/MakeIntegerSequence.adoc[`MakeIntegerSequence`] 
| `MakeIntegerSequence` is defined to simplify creation of `bslmf&colon;&colon;IntegerSequence` type that represents a collection of increasing integer values of the specified type `t&lowbar;T` in a range of &lsqb;0&period;&period;t&lowbar;N) having&rsqb; the specified t&lowbar;N&hyphen;value length&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_ConcatUtil_t.adoc[`MakeIntegerSequence&lowbar;ConcatUtil&lowbar;t`] 
| `bslmf&colon;&colon;MakeIntegerSequence&lowbar;ConcatUtil&lowbar;t` is an alias to the result type of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;ConcatUtil` meta&hyphen;function&period;
| xref:BloombergLP/bslmf/MovableRef.adoc[`MovableRef`] 
| The alias template `MovableRef&lt;t&lowbar;TYPE&gt;` yields an r&hyphen;value reference of type `t&lowbar;TYPE&amp;&amp;`&period;
| xref:BloombergLP/bslmf/MovableRef_Deduced.adoc[`MovableRef&lowbar;Deduced`] 
| This component&hyphen;private alias template names the type `t&lowbar;TYPE&amp;&amp;` if and only if the specified `t&lowbar;TYPE` is not an lvalue reference&period;
| xref:BloombergLP/bslmf/Switch2.adoc[`Switch2`] 
| `switch` meta&hyphen;function among two types&period;
| xref:BloombergLP/bslmf/Switch3.adoc[`Switch3`] 
| `switch` meta&hyphen;function among three types&period;
| xref:BloombergLP/bslmf/Switch4.adoc[`Switch4`] 
| `switch` meta&hyphen;function among four types&period;
| xref:BloombergLP/bslmf/Switch5.adoc[`Switch5`] 
| `switch` meta&hyphen;function among five types&period;
| xref:BloombergLP/bslmf/Switch6.adoc[`Switch6`] 
| Select the type associated with selector value 6&period;
| xref:BloombergLP/bslmf/Switch7.adoc[`Switch7`] 
| Select the type associated with selector value 7&period;
| xref:BloombergLP/bslmf/Switch8.adoc[`Switch8`] 
| Select the type associated with selector value 8&period;
| xref:BloombergLP/bslmf/Switch9.adoc[`Switch9`] 
| Alias for a nine&hyphen;way `Switch` metafunction&period;
| xref:BloombergLP/bslmf/TypeList0.adoc[`TypeList0`] 
| Typelist of zero type parameters&period;
| xref:BloombergLP/bslmf/TypeList1.adoc[`TypeList1`] 
| Typelist of one type parameter&period;
| xref:BloombergLP/bslmf/TypeList10.adoc[`TypeList10`] 
| Typelist of ten type parameters&period;
| xref:BloombergLP/bslmf/TypeList11.adoc[`TypeList11`] 
| Typelist of eleven type parameters&period;
| xref:BloombergLP/bslmf/TypeList12.adoc[`TypeList12`] 
| Typelist of twelve type parameters&period;
| xref:BloombergLP/bslmf/TypeList13.adoc[`TypeList13`] 
| Typelist of thirteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList14.adoc[`TypeList14`] 
| Typelist of fourteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList15.adoc[`TypeList15`] 
| Typelist of fifteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList16.adoc[`TypeList16`] 
| Typelist of sixteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList17.adoc[`TypeList17`] 
| Typelist of seventeen type parameters&period;
| xref:BloombergLP/bslmf/TypeList18.adoc[`TypeList18`] 
| Typelist of eighteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList19.adoc[`TypeList19`] 
| Typelist of nineteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList2.adoc[`TypeList2`] 
| Typelist of two type parameters&period;
| xref:BloombergLP/bslmf/TypeList20.adoc[`TypeList20`] 
| Typelist of twenty type parameters&period;
| xref:BloombergLP/bslmf/TypeList3.adoc[`TypeList3`] 
| Typelist of three type parameters&period;
| xref:BloombergLP/bslmf/TypeList4.adoc[`TypeList4`] 
| Typelist of four type parameters&period;
| xref:BloombergLP/bslmf/TypeList5.adoc[`TypeList5`] 
| Typelist of five type parameters&period;
| xref:BloombergLP/bslmf/TypeList6.adoc[`TypeList6`] 
| Typelist of six type parameters&period;
| xref:BloombergLP/bslmf/TypeList7.adoc[`TypeList7`] 
| Typelist of seven type parameters&period;
| xref:BloombergLP/bslmf/TypeList8.adoc[`TypeList8`] 
| Typelist of eight type parameters&period;
| xref:BloombergLP/bslmf/TypeList9.adoc[`TypeList9`] 
| Typelist of nine type parameters&period;
| xref:BloombergLP/bslmf/TypeListNil.adoc[`TypeListNil`] 
| Sentinel type representing an empty typelist element&period;
| xref:BloombergLP/bslmf/TypeListTypeOf.adoc[`TypeListTypeOf`] 
| Classic Bloomberg code uses a 1&hyphen;based index into the type list&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/operator_comma.adoc[`operator,`] 
| Return `InvokeResult&lowbar;VoidChecker()` if the left argument is of type cv&hyphen;`void`&semi; otherwise `bslmf&colon;&colon;Tag&lt;false&gt;()`&period; This overload of the comma operator is declared but not defined, and is intended to be used in metafunctions in an unevaluated context to detect void expressions&period; For any non&hyphen;void expression `expr`, `(expr,InvokeResult&lowbar;VoidChecker())`, will match this overload and produce a result of type `bslmf&colon;&colon;Tag&lt;false&gt;`&period; However, `const t&lowbar;TYPE&amp;` will not match `void`, so if `expr` is a void expression, the built&hyphen;in comma operator is matched and the result will have type `InvokeResult&lowbar;VoidChecker` (i&period;e&period;, the second argument)&period;
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/IsBitwiseCopyable_v.adoc[`IsBitwiseCopyable&lowbar;v`] 
| This template variable represents the result value of the `bslmf&colon;&colon;IsBitwiseCopyable` meta&hyphen;function&period;
| xref:BloombergLP/bslmf/IsBitwiseMoveable_v.adoc[`IsBitwiseMoveable&lowbar;v`] 
| This template variable represents the result value of the `bslmf&colon;&colon;IsBitwiseMoveable` meta&hyphen;function&period;
|===


== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/BooleanTestable.adoc[`BooleanTestable`] 
| Concept that a type supports boolean testing and logical negation with the conventional semantics defined by the C&plus;&plus;20 standard &lsqb;concept&period;booleantestable&rsqb;&period;
| xref:BloombergLP/bslmf/ContainerCompatibleRange.adoc[`ContainerCompatibleRange`] 
| Require that (template parameter) `t&lowbar;RANGE` meets the requirements of input range and that the values referenced by the iterators of that range type have the same type or are convertible to the (template parameter) `t&lowbar;TYPE`&period;
|===



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