[#bsl-integral_constant-02]
= xref:bsl.adoc[bsl]::integral&lowbar;constant
:relfileprefix: ../
:mrdocs:

Metafunction representing a compile&hyphen;time constant of the specified (template parameter) `t&lowbar;TYPE` with the specified (template parameter) `t&lowbar;VALUE`&period;

== Synopsis

Declared in `&lt;bslmf&lowbar;integralconstant&period;h&gt;`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class t&lowbar;TYPE,
    t&lowbar;TYPE t&lowbar;VALUE&gt;
struct integral&lowbar;constant
    : std::integral&lowbar;constant&lt;t&lowbar;TYPE, t&lowbar;VALUE&gt;
----

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `std::integral&lowbar;constant&lt;t&lowbar;TYPE, t&lowbar;VALUE&gt;`
| 
|===

== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:bsl/integral_constant-02/type.adoc[`type`] 
| Alias for this `integral&lowbar;constant` specialization&period;
| xref:bsl/integral_constant-02/value_type.adoc[`value&lowbar;type`] 
| 
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:bsl/integral_constant-02/operator_call.adoc[`operator()`] 
| Return a copy of the template argument `t&lowbar;VALUE`&period;
| xref:bsl/integral_constant-02/2conversion.adoc[`operator value&lowbar;type`] 
| 
|===


== Static Data Members

[cols="1"]
|===
| Name
| xref:bsl/integral_constant-02/value.adoc[`value`] 
|===


== Derived Classes

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslma/AAModelBsl.adoc[`AAModelBsl`] 
| Model tag for bsl&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelIsSupported-00.adoc[`AAModelIsSupported&lt;TYPE, AAModelLegacy&gt;`] 
| Specialization of `AAModelIsSupported` for `MODEL &equals;&equals; AAModelStl`, yielding `true&lowbar;type` if `TYPE` can use `bslma&colon;&colon;Allocator &ast;` as its memory resource&period; Specifically, it is true if `UsesBslmaAllocator&lt;TYPE&gt;` is true or if `TYPE&colon;&colon;allocator&lowbar;type` exists and is convertible from `bslma&colon;&colon;Allocator &ast;`&period;
| xref:BloombergLP/bslma/AAModelIsSupported-01a.adoc[`AAModelIsSupported&lt;TYPE, AAModelBsl&gt;`] 
| Specialization of `AAModelIsSupported` for `MODEL &equals;&equals; AAModelBsl`, yielding `true&lowbar;type` if `TYPE&colon;&colon;allocator&lowbar;type` exists and is convertible from `bsl&colon;&colon;allocator&lt;char&gt;`&period;
| xref:BloombergLP/bslma/AAModelIsSupported-01d.adoc[`AAModelIsSupported&lt;TYPE, AAModelStl&gt;`] 
| Specialization of `AAModelIsSupported` for `MODEL &equals;&equals; AAModelStl`, yielding `true&lowbar;type` if `TYPE&colon;&colon;allocator&lowbar;type` exists&semi; otherwise, yielding `false&lowbar;type` unless `AAModelIsSupported&lt;TYPE, AAModelBsl&gt;` is true&period; The latter condition exists so that *bsl&hyphen;AA* always implies *stl&hyphen;AA* even if `AAModelIsSupported&lt;TYPE, AAModelBsl&gt;` is explicitly specialized to true for a type that does not have an `allocator&lowbar;type` member&period;
| xref:BloombergLP/bslma/AAModelIsSupported-0c.adoc[`AAModelIsSupported&lt;TYPE, AAModelPmr&gt;`] 
| Specialization of `AAModelIsSupported` for `MODEL &equals;&equals; AAModelPmr`, yielding `true&lowbar;type` if `TYPE&colon;&colon;allocator&lowbar;type` exists and is convertible from `bsl&colon;&colon;polymorphic&lowbar;allocator&lt;char&gt;`&period;
| xref:BloombergLP/bslma/AAModelLegacy.adoc[`AAModelLegacy`] 
| Model tag for legacy&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelNone.adoc[`AAModelNone`] 
| Model tag for non&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelPmr.adoc[`AAModelPmr`] 
| Model tag for pmr&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelStl.adoc[`AAModelStl`] 
| Model tag for stl&hyphen;AA types&period;
| xref:BloombergLP/bslalg/ArrayPrimitives_CanBitwiseCopy.adoc[`ArrayPrimitives&lowbar;CanBitwiseCopy`] 
| Metafunction that is `true` when `FROM&lowbar;TYPE` and `TO&lowbar;TYPE` are the same type (ignoring top&hyphen;level `const`) and that type is bit&hyphen;wise copyable&period;
| xref:BloombergLP/bdlat_EnumFunctions/HasFallbackEnumerator-00.adoc[`HasFallbackEnumerator`] 
| This `struct` should be specialized for third&hyphen;party types that need to declare the fact that they have a fallback enumerator value&period; Clients that specialize this struct must ensure that if `HasFallbackEnumerator&lt;TYPE&gt;&colon;&colon;value` is true, then `IsEnumeration&lt;TYPE&gt;&colon;&colon;value` is also true&semi; otherwise, the behavior is undefined&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/bslalg/HasTrait.adoc[`HasTrait`] 
| This meta&hyphen;function evaluates to `bsl&colon;&colon;true&lowbar;type` if the (template parameter) `TYPE` has the (template parameter) `TRAIT`, and to `bsl&colon;&colon;false&lowbar;type` otherwise&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/IsBitwiseCopyable-08a.adoc[`IsBitwiseCopyable&lt;bsl::pair&lt;T1, T2&gt;&gt;`] 
| 
| xref:BloombergLP/bslmf/IsBitwiseEqualityComparable-009.adoc[`IsBitwiseEqualityComparable&lt;bsl::pair&lt;T1, T2&gt;&gt;`] 
| 
| xref:BloombergLP/bslmf/IsBitwiseMoveable-01d.adoc[`IsBitwiseMoveable&lt;bsl::pair&lt;T1, T2&gt;&gt;`] 
| 
| xref:BloombergLP/bslmf/IsBitwiseMoveable-07e.adoc[`IsBitwiseMoveable&lt;bslma::ManagedPtrDeleter&gt;`] 
| 
| xref:BloombergLP/bslmf/IsBitwiseMoveable-09dc.adoc[`IsBitwiseMoveable&lt;bslstl::HashTable&lt;KEY&lowbar;CONFIG, HASHER, COMPARATOR, ALLOCATOR&gt;&gt;`] 
| 
| xref:BloombergLP/bslmf/IsBitwiseMoveable-0fd8.adoc[`IsBitwiseMoveable&lt;bslstl::BidirectionalNodePool&lt;VALUE, ALLOCATOR&gt;&gt;`] 
| 
| xref:BloombergLP/bdlat_ChoiceFunctions/IsChoice-04.adoc[`IsChoice`] 
| This `struct` should be specialized for third&hyphen;party types that need to expose &quot;choice&quot; behavior&period; See the component&hyphen;level documentation for further information&period;
| xref:BloombergLP/bdlat_CustomizedTypeFunctions/IsCustomizedType-04.adoc[`IsCustomizedType`] 
| This `struct` should be specialized for third&hyphen;party types that need to expose &quot;customized type&quot; behavior&period; See the component&hyphen;level documentation for further information&period;
| xref:BloombergLP/bdlar/IsDynamic.adoc[`IsDynamic`] 
| Meta&hyphen;function indicating whether the specified `t&lowbar;TYPE` is in the `bdlat` dynamic&hyphen;type category&period;
| xref:BloombergLP/bdlat_EnumFunctions/IsEnumeration-0c.adoc[`IsEnumeration`] 
| This `struct` should be specialized for third&hyphen;party types that need to expose &quot;enumeration&quot; behavior&period; See the component&hyphen;level documentation for further information&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/bslstl/Function_SmallObjectOptimization/IsInplaceFunc.adoc[`IsInplaceFunc`] 
| This class is a Boolean metafunction that determines whether or not the specified `FN` template parameter should be allocated within the footprint of the `InplaceBuffer` (i&period;e&period;, using the small&hyphen;object optimization&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/bdlat_SequenceFunctions/IsSequence-0a.adoc[`IsSequence`] 
| This `struct` should be specialized for third&hyphen;party types that need to expose &quot;sequence&quot; behavior&period; See the component&hyphen;level documentation for further information&period;
| xref:BloombergLP/bdlar/IsSimple-0c.adoc[`IsSimple`] 
| Meta&hyphen;function indicating whether the specified `TYPE` is in the `bdlat` simple&hyphen;type category&period;
| 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/bdljsn/NumberUtil_IsSigned.adoc[`NumberUtil&lowbar;IsSigned`] 
| This class will be a `bsl&colon;&colon;true&lowbar;type` if the specified (template parameter type) `t&lowbar;TYPE` is a signed type, and `bsl&colon;&colon;false&lowbar;type` otherwise&period; `t&lowbar;TYPE` shall be an integral type&period; Note that currently bsl&colon;&colon;is&lowbar;signed is not available for C&plus;&plus;03 platforms&period;
| xref:BloombergLP/bslstl/Optional_ConstructsFromType.adoc[`Optional&lowbar;ConstructsFromType`] 
| This metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if `t&lowbar;ANY&lowbar;TYPE` is not derived from `bsl&colon;&colon;optional&lt;t&lowbar;TYPE&gt;`, `t&lowbar;ANY&lowbar;TYPE` is not a tag type, and `t&lowbar;TYPE` is constructible from `t&lowbar;ANY&lowbar;TYPE`&period;
| xref:BloombergLP/bslstl/Optional_PropagatesAllocator.adoc[`Optional&lowbar;PropagatesAllocator`] 
| This metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if `t&lowbar;TYPE` is an allocator&hyphen;aware const type, and if `t&lowbar;ANY&lowbar;TYPE` is the same as `t&lowbar;TYPE`, minus the cv qualification&period; This trait is used to enable a constructor overload for a const qualified allocator&hyphen;aware `ValueType` taking an rvalue of Optional&lowbar;Base of the non&hyphen;const qualified `ValueType`&period; Such an overload needs to propagate the allocator&period;
| xref:bsl/Pair_ConstructionParametersPackLength.adoc[`Pair&lowbar;ConstructionParametersPackLength`] 
| This component&hyphen;private component&hyphen;private meta&hyphen;function determines the number of elements in a tuple containing parameters for piecewise construction of a `bsl&colon;&colon;pair` member having the specified `TYPE`&period; Result value depends on the `TYPE`, whether it takes a `bslma&colon;&colon;Allocator&ast;` constructor argument and, if so, whether that argument follows an argument of type `bsl&colon;&colon;allocator&lowbar;arg&lowbar;t`&period;
| xref:BloombergLP/bslstl/Pair_IndexOfType-006.adoc[`Pair&lowbar;IndexOfType&lt;T2, T1, T2&gt;`] 
| This partial specialization of `Pair&lowbar;IndexOfType` returns the index of second element of pair&period;
| xref:BloombergLP/bslstl/Pair_IndexOfType-00c.adoc[`Pair&lowbar;IndexOfType&lt;T1, T1, T2&gt;`] 
| This partial specialization of `Pair&lowbar;IndexOfType` returns the index of first element of pair&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-002.adoc[`SimpleTypeIdOf&lt;bdlt::TimeTz&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-003.adoc[`SimpleTypeIdOf&lt;long long&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-00d.adoc[`SimpleTypeIdOf&lt;bdlt::DateTz&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-010.adoc[`SimpleTypeIdOf&lt;bdlt::Date&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-01d.adoc[`SimpleTypeIdOf&lt;unsigned short&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-01f.adoc[`SimpleTypeIdOf&lt;bdldfp::Decimal64&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-02.adoc[`SimpleTypeIdOf&lt;bsl::vector&lt;char&gt;&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-032.adoc[`SimpleTypeIdOf&lt;unsigned long&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0386d.adoc[`SimpleTypeIdOf&lt;short&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0386f.adoc[`SimpleTypeIdOf&lt;signed char&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-03b.adoc[`SimpleTypeIdOf&lt;char&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-068.adoc[`SimpleTypeIdOf&lt;float&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-06a.adoc[`SimpleTypeIdOf&lt;bdlt::Time&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-08.adoc[`SimpleTypeIdOf&lt;bsl::string&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0902.adoc[`SimpleTypeIdOf&lt;bool&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-090c.adoc[`SimpleTypeIdOf&lt;unsigned char&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0a.adoc[`SimpleTypeIdOf&lt;int&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0b6.adoc[`SimpleTypeIdOf&lt;unsigned long long&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0bb.adoc[`SimpleTypeIdOf&lt;double&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0d4.adoc[`SimpleTypeIdOf&lt;long&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0dc.adoc[`SimpleTypeIdOf&lt;unsigned int&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0e.adoc[`SimpleTypeIdOf&lt;bdlt::Datetime&gt;`] 
| 
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0f.adoc[`SimpleTypeIdOf&lt;bdlt::DatetimeTz&gt;`] 
| 
| xref:BloombergLP/bslma/UsesBslmaAllocator-01f.adoc[`UsesBslmaAllocator&lt;bsl::pair&lt;T1, T2&gt;&gt;`] 
| 
| xref:BloombergLP/bslma/UsesBslmaAllocator-020.adoc[`UsesBslmaAllocator`] 
| This metafunction is derived from `true&lowbar;type` if `TYPE` adheres to the `bslma` allocator usage idiom and `false&lowbar;type` otherwise&period; Note that this trait must be explicitly associated with a type in order for this metafunction to return true&semi; simply having a constructor that implicitly converts `bslma&colon;&colon;Allocator &ast;` to `TYPE` is deprecated as a means of indicating that a type follows the `bslma` allocator usage idiom&period;
| xref:BloombergLP/bslstl/Variant_AssignsFromType.adoc[`Variant&lowbar;AssignsFromType`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if (template parameter) `t&lowbar;TYPE` is neither a tag type nor the type (template parameter) `t&lowbar;VARIANT` (modulo cv&hyphen;qualification), there is a unique best match alternative in `t&lowbar;VARIANT` for `std&colon;&colon;declval&lt;t&lowbar;TYPE&gt;()`, and that alternative is constructible and assignable from `std&colon;&colon;declval&lt;t&lowbar;TYPE&gt;()`&semi; otherwise, this metafunction is derived from `bsl&colon;&colon;false&lowbar;type`&period;
| xref:BloombergLP/bslstl/Variant_ConstructsFromType.adoc[`Variant&lowbar;ConstructsFromType`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if (template parameter) `t&lowbar;TYPE` is neither a tag type, nor the type (template parameter) `t&lowbar;VARIANT` (modulo cv&hyphen;qualification), nor the corresponding (possibly cv&hyphen;qualified) `std&colon;&colon;variant` type, there is a unique best match alternative in `t&lowbar;VARIANT` for `std&colon;&colon;declval&lt;t&lowbar;TYPE&gt;()`, and that alternative is constructible from `std&colon;&colon;declval&lt;t&lowbar;TYPE&gt;()`&semi; otherwise, this metafunction is derived from `bsl&colon;&colon;false&lowbar;type`&period;
| xref:BloombergLP/bslstl/Variant_ConvertsWithoutNarrowing-0a.adoc[`Variant&lowbar;ConvertsWithoutNarrowing&lt;t&lowbar;DEST, t&lowbar;SOURCE, bsl::void&lowbar;t&lt;decltype(Variant&lowbar;ArrayHelper&lt;t&lowbar;DEST&gt;&lcub;&lcub;std&colon;&colon;declval&lt;t&lowbar;SOURCE&gt;()&rcub;&rcub;)&gt;&gt;`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if (template parameter) `t&lowbar;SOURCE` can be converted to (template parameter) `t&lowbar;DEST` without narrowing, and `bsl&colon;&colon;false&lowbar;type` otherwise&period; A conversion from pointer or pointer&hyphen;to&hyphen;member type to cv `bool` is considered narrowing even if the compiler does not implement P1957R2 (which was adopted as a DR)&semi; however, on compilers that do not implement P1957R2, we do not have the ability to check whether a user&hyphen;defined conversion sequence to cv `bool` would use a narrowing standard conversion, so on those compilers, we permit conversion to a `t&lowbar;DEST` that is cv `bool` only if `t&lowbar;SOURCE` is also cv `bool`, and not when `t&lowbar;SOURCE` is a class type&period; This behavior is not expected to pose a problem for users migrating from `bdlb&colon;&colon;Variant`, because that class does not support implicit conversions from an argument type to an alternative type&period;
| xref:BloombergLP/bslstl/Variant_CountCVType-03.adoc[`Variant&lowbar;CountCVType`] 
| This component&hyphen;private metafunction calculates the number of times (template parameter) `t&lowbar;TYPE` occurs in (template parameters) `t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;`, where two types that differ only in top&hyphen;level cv&hyphen;qualification are considered to be the same&period;
| xref:BloombergLP/bslstl/Variant_CountCVType-09.adoc[`Variant&lowbar;CountCVType&lt;t&lowbar;TYPE, BSLSTL&lowbar;VARIANT&lowbar;NOT&lowbar;A&lowbar;TYPE&gt;`] 
| Specialization for purposes of the sim&lowbar;cpp11&lowbar;features&period;pl script&period;
| xref:BloombergLP/bslstl/Variant_CountType-0c.adoc[`Variant&lowbar;CountType&lt;t&lowbar;TYPE, BSLSTL&lowbar;VARIANT&lowbar;NOT&lowbar;A&lowbar;TYPE&gt;`] 
| Specialization for purposes of the sim&lowbar;cpp11&lowbar;features&period;pl script&period;
| xref:BloombergLP/bslstl/Variant_CountType-0d.adoc[`Variant&lowbar;CountType`] 
| This component&hyphen;private metafunction calculates the number of times (template parameter) `t&lowbar;TYPE` occurs in (template parameters) `t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;`&period; An alternative must have the same cv&hyphen;qualification as `t&lowbar;TYPE` in order to be counted&period;
| xref:BloombergLP/bslstl/Variant_HasUniqueCVType-0f.adoc[`Variant&lowbar;HasUniqueCVType&lt;t&lowbar;TYPE, bsl::variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;&gt;`] 
| 
| xref:BloombergLP/bslstl/Variant_HasUniqueType-02.adoc[`Variant&lowbar;HasUniqueType&lt;t&lowbar;TYPE, bsl::variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;&gt;`] 
| 
| xref:BloombergLP/bslstl/Variant_IsAlternativeConstructibleFrom-0e.adoc[`Variant&lowbar;IsAlternativeConstructibleFrom`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if there is a unique best match alternative in (template parameter) `t&lowbar;VARIANT` for &apos;std&colon;&colon;declval&lt;t&lowbar;TYPE&gt;() and that alternative is constructible from `std&colon;&colon;declval&lt;t&lowbar;TYPE&gt;(), and `bsl&colon;&colon;false&lowbar;type&apos; otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsBitwiseMoveableAll-0c.adoc[`Variant&lowbar;IsBitwiseMoveableAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template arguments are bitwise moveable, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsCopyAssignableAll-0d.adoc[`Variant&lowbar;IsCopyAssignableAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are copy assignable, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsCopyConstructibleAll-03.adoc[`Variant&lowbar;IsCopyConstructibleAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are copy constructible, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsMoveAssignableAll-0e.adoc[`Variant&lowbar;IsMoveAssignableAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are move assignable, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsMoveConstructibleAll-05.adoc[`Variant&lowbar;IsMoveConstructibleAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are move constructible, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsSameReturnType-02.adoc[`Variant&lowbar;IsSameReturnType`] 
| This component&hyphen;private metafunction derives from `bsl&colon;&colon;true&lowbar;type` if, for each alternative `ALTi` in (template parameter) `t&lowbar;VARIANT` with index less than or equal to (template parameter) `t&lowbar;INDEX`, `decltype(std&colon;&colon;declval&lt;t&lowbar;VISITOR&gt;(std&colon;&colon;declval&lt;ALTi&gt;()))` is `t&lowbar;RET`&semi; otherwise, this metafunction derives from `bsl&colon;&colon;false&lowbar;type`&period; Note that `ALTi` has the cv&hyphen; and ref&hyphen;qualifiers from `t&lowbar;VARIANT` added to it&period; This metafunction is used to determine whether invoking the visitor results in the same type and value category for all alternatives&period;
| xref:BloombergLP/bdlb/Variant_ReturnValueHelper.adoc[`Variant&lowbar;ReturnValueHelper`] 
| This struct is a component&hyphen;private meta&hyphen;function&period; Do _not_ use&period; This meta&hyphen;function checks whether the template parameter type `VISITOR` has the member `ResultType` defined using &quot;SFINAE&quot; (Substitution Failure Is Not An Error)&period; A `value` of `true` indicates `VISITOR&colon;&colon;ResultType` exists, and `false` otherwise&period;
| xref:BloombergLP/bslstl/Variant_TypeToIndexImpl-07.adoc[`Variant&lowbar;TypeToIndexImpl&lt;t&lowbar;INDEX, t&lowbar;TYPE, BSLSTL&lowbar;VARIANT&lowbar;NOT&lowbar;A&lowbar;TYPE&gt;`] 
| This partial specialization is used when the list of alternatives `t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;` is empty, i&period;e&period;, `t&lowbar;TYPE` wasn&apos;t found in the originally supplied list of alternatives&period;
| xref:BloombergLP/bslstl/Variant_UsesBslmaAllocatorAny-0e.adoc[`Variant&lowbar;UsesBslmaAllocatorAny`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if at least one template argument uses an allocator, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_isAlternativeAssignableFrom-07.adoc[`Variant&lowbar;isAlternativeAssignableFrom`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if there is a unique best match alternative in (template parameter) `t&lowbar;VARIANT` for `std&colon;&colon;declval&lt;t&lowbar;TYPE&gt;()` and that alternative is both constructible and assignable from `std&colon;&colon;declval&lt;t&lowbar;TYPE&gt;()`, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_arithmetic.adoc[`is&lowbar;arithmetic`] 
| This `struct` template implements the `is&lowbar;arithmetic` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;comp&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is an arithmetic type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is an arithmetic type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_convertible.adoc[`is&lowbar;convertible`] 
| This `struct` template implements the `is&lowbar;convertible` meta&hyphen;function defined in the C&plus;&plus;11 standard to determine whether the (template parameter) `t&lowbar;FROM&lowbar;TYPE` is implicitly convertible to the (template parameter) `t&lowbar;TO&lowbar;TYPE`&period;
| xref:bsl/is_copy_constructible.adoc[`is&lowbar;copy&lowbar;constructible`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is copy constructible&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is copy constructible, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This meta&hyphen;function has the same syntax as the `is&lowbar;copy&lowbar;constructible` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;prop&rsqb;&semi; on C&plus;&plus;03 platforms, however, this meta&hyphen;function defaults to `true&lowbar;type` for all types that are not explicitly declared to have the `bslmf&colon;&colon;IsNonCopyable` trait using the `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION` macro&period; To mark a type as non&hyphen;copyable, `bslmf&colon;&colon;IsNonCopyable` must be specialized (for that type) to inherit from `bsl&colon;&colon;true&lowbar;type`&period;
| xref:bsl/is_empty.adoc[`is&lowbar;empty`] 
| This `struct` is a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is an empty class type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is empty, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This meta&hyphen;function has the same syntax as the `is&lowbar;empty` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;prop&rsqb;&semi; on C&plus;&plus;03 platforms, however, this meta&hyphen;function defaults to `true&lowbar;type` if `t&lowbar;TYPE` is a `class` or `struct` with no non&hyphen;static data members other than bit&hyphen;fields of length 0, no virtual member functions, no virtual base classes, and no base class `B` for which `is&lowbar;empty&lt;B&gt;&colon;&colon;value` is `false`&semi; otherwise `is&lowbar;empty` defaults to `false&lowbar;type`&period; Note that this meta&hyphen;function will fail to compile for a union that is the same size as an empty class in C&plus;&plus;03&period;
| xref:bsl/is_enum.adoc[`is&lowbar;enum`] 
| This `struct` template implements the `is&lowbar;enum` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is an enumerated type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is an enumerated type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_floating_point.adoc[`is&lowbar;floating&lowbar;point`] 
| This `struct` template implements the `is&lowbar;floating&lowbar;point` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a floating&hyphen;point type&period;
| xref:bsl/is_function-05.adoc[`is&lowbar;function`] 
| This `struct` template implements the `is&lowbar;function` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a function type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is a function type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This implementation relies on the fact that neither function types nor reference types can be cv&hyphen;qualified so that `is&lowbar;const&lt;const t&lowbar;TYPE&gt;` will actually yield `false`&period;
| xref:bsl/is_fundamental-09.adoc[`is&lowbar;fundamental`] 
| This `struct` template implements a meta&hyphen;function for checking if a type is fundamental as defined in the C&plus;&plus;11 standard &lsqb;basic&period;fundamental&rsqb;&period; Note that this is subtly differemt from `bslmf&colon;&colon;IsFundamental`, which also returns `true&lowbar;type` for references to fundamental types&period;
| xref:bsl/is_integral.adoc[`is&lowbar;integral`] 
| This `struct` template implements the `is&lowbar;integral` meta&hyphen;function defined in the C&plus;&plus;11 standard to determine if the (template parameter) `t&lowbar;TYPE` is an integral type&period;
| xref:bsl/is_lvalue_reference.adoc[`is&lowbar;lvalue&lowbar;reference`] 
| Metafunction that is `true` if the (template parameter) `t&lowbar;TYPE` is an lvalue reference type&period;
| xref:bsl/is_polymorphic.adoc[`is&lowbar;polymorphic`] 
| This `struct` template implements the `is&lowbar;polymorphic` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;prop&rsqb;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:bsl/variant_size-09.adoc[`variant&lowbar;size&lt;variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;&gt;`] 
| 
|===


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