bsl::integral_constant

Synopsis

Declared in <bslmf_integralconstant.h>

template<
    class t_TYPE,
    t_TYPE t_VALUE>
struct integral_constant
    : std::integral_constant<t_TYPE, t_VALUE>

Base Classes

Name	Description
`std::integral_constant<t_TYPE, t_VALUE>`

Type Aliases

Name	Description
`type`	Alias for this `integral_constant` specialization.
`value_type`	Alias for the (template parameter) `t_TYPE`.

Member Functions

Name	Description
`operator()`	Return a copy of the template argument `t_VALUE`.
`operator t_TYPE`	Return a copy of the template argument `t_VALUE`.

Static Data Members

Name	Description
`value`	The compile-time constant value of this metafunction.

Derived Classes

Name	Description
`AAModelBsl`	Model tag for bsl-AA types.
`AAModelIsSupported<TYPE, AAModelLegacy>`	Specialization of `AAModelIsSupported` for the legacy-AA model.
`AAModelIsSupported<TYPE, AAModelBsl>`	Specialization of `AAModelIsSupported` for `MODEL == AAModelBsl`, yielding `true_type` if `TYPE::allocator_type` exists and is convertible from `bsl::allocator<char>`.
`AAModelIsSupported<TYPE, AAModelStl>`	Specialization of `AAModelIsSupported` for the stl-AA model.
`AAModelIsSupported<TYPE, AAModelPmr>`	Specialization of `AAModelIsSupported` for the pmr-AA model.
`AAModelLegacy`	Model tag for legacy-AA types.
`AAModelNone`	Model tag for non-AA types.
`AAModelPmr`	Model tag for pmr-AA types.
`AAModelStl`	Model tag for stl-AA types.
`ArrayPrimitives_CanBitwiseCopy`	Metafunction that is `true` when `FROM_TYPE` and `TO_TYPE` are the same type (ignoring top-level `const`) and that type is bit-wise copyable.
`HasFallbackEnumerator`	Meta-function that detects whether `TYPE` has a fallback enumerator.
`HasPointerSemantics`	Metafunction indicating whether the (template parameter) `t_TYPE` has pointer-like semantics.
`HasTrait`	This meta-function evaluates to `bsl::true_type` if the (template parameter) `TYPE` has the (template parameter) `TRAIT`, and to `bsl::false_type` otherwise.
`IsAccessibleBaseOf`	Meta-function for detecting if one class is an accessible base of another.
`IsBitwiseCopyable<bsl::pair<T1, T2>>`	Trait indicating `pair` is bitwise-copyable when both elements are.
`IsBitwiseEqualityComparable<bsl::pair<T1, T2>>`	Trait indicating `pair` is bitwise equality-comparable when both elements are and the pair has no padding.
`IsBitwiseMoveable<bsl::pair<T1, T2>>`	Trait indicating `pair` is bitwise-moveable when both elements are.
`IsBitwiseMoveable<bslma::ManagedPtrDeleter>`	Specialize `IsBitwiseMoveable` to indicate that `ManagedPtrDeleter` is bitwise moveable.
`IsBitwiseMoveable<bslstl::HashTable<KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR>>`	Trait indicating `HashTable` is bitwise-movable when its parts are.
`IsBitwiseMoveable<bslstl::BidirectionalNodePool<VALUE, ALLOCATOR>>`	Trait indicating `BidirectionalNodePool` is bitwise moveable when its allocator is.
`IsChoice`	This `struct` should be specialized for third-party types that need to expose "choice" behavior. See the component-level documentation for further information.
`IsCustomizedType`	Meta-function that detects whether `TYPE` exposes customized-type behavior.
`IsDynamic`	Meta-function indicating whether the specified `t_TYPE` is in the `bdlat` dynamic-type category.
`IsEnumeration`	Meta-function that detects whether `TYPE` exposes enumeration behavior.
`IsFunctionPointer`	Meta-function to determine if a type is a free function pointer.
`IsInplaceFunc`	Boolean metafunction reporting whether `FN` uses the inplace buffer.
`IsMemberFunctionPointer`	Meta-function to determine if a type is a member function pointer.
`IsSequence`	This `struct` should be specialized for third-party types that need to expose "sequence" behavior. See the component-level documentation for further information.
`IsSimple`	Meta-function indicating whether the specified `TYPE` is in the `bdlat` simple-type category.
`MetaInt`	Distinct type representing a non-negative compile-time integer value.
`NumberUtil_IsSigned`	Metafunction yielding whether integral `t_TYPE` is signed.
`Optional_ConstructsFromType`	Metafunction detecting constructibility from a non-optional type.
`Optional_PropagatesAllocator`	Metafunction detecting allocator propagation for const value types.
`Pair_ConstructionParametersPackLength`	Metafunction giving the piecewise-construction argument-pack length.
`Pair_IndexOfType<T2, T1, T2>`	This partial specialization of `Pair_IndexOfType` returns the index of second element of pair.
`Pair_IndexOfType<T1, T1, T2>`	This partial specialization of `Pair_IndexOfType` returns the index of first element of pair.
`SimpleTypeIdOf<bdlt::TimeTz>`	Specialization of `SimpleTypeIdOf` for `bdlt::TimeTz`.
`SimpleTypeIdOf<long long>`	Specialization of `SimpleTypeIdOf` for `long long`.
`SimpleTypeIdOf<bdlt::DateTz>`	Specialization of `SimpleTypeIdOf` for `bdlt::DateTz`.
`SimpleTypeIdOf<bdlt::Date>`	Specialization of `SimpleTypeIdOf` for `bdlt::Date`.
`SimpleTypeIdOf<unsigned short>`	Specialization of `SimpleTypeIdOf` for `unsigned short`.
`SimpleTypeIdOf<bdldfp::Decimal64>`	Specialization of `SimpleTypeIdOf` for `bdldfp::Decimal64`.
`SimpleTypeIdOf<bsl::vector<char>>`	Specialization of `SimpleTypeIdOf` for `bsl::vector<char>`.
`SimpleTypeIdOf<unsigned long>`	Specialization of `SimpleTypeIdOf` for `unsigned long`.
`SimpleTypeIdOf<short>`	Specialization of `SimpleTypeIdOf` for `short`.
`SimpleTypeIdOf<signed char>`	Specialization of `SimpleTypeIdOf` for `signed char`.
`SimpleTypeIdOf<char>`	Specialization of `SimpleTypeIdOf` for `char`.
`SimpleTypeIdOf<float>`	Specialization of `SimpleTypeIdOf` for `float`.
`SimpleTypeIdOf<bdlt::Time>`	Specialization of `SimpleTypeIdOf` for `bdlt::Time`.
`SimpleTypeIdOf<bsl::string>`	Specialization of `SimpleTypeIdOf` for `bsl::string`.
`SimpleTypeIdOf<bool>`	Specialization of `SimpleTypeIdOf` for `bool`.
`SimpleTypeIdOf<unsigned char>`	Specialization of `SimpleTypeIdOf` for `unsigned char`.
`SimpleTypeIdOf<int>`	Specialization of `SimpleTypeIdOf` for `int`.
`SimpleTypeIdOf<unsigned long long>`	Specialization of `SimpleTypeIdOf` for `unsigned long long`.
`SimpleTypeIdOf<double>`	Specialization of `SimpleTypeIdOf` for `double`.
`SimpleTypeIdOf<long>`	Specialization of `SimpleTypeIdOf` for `long`.
`SimpleTypeIdOf<unsigned int>`	Specialization of `SimpleTypeIdOf` for `unsigned int`.
`SimpleTypeIdOf<bdlt::Datetime>`	Specialization of `SimpleTypeIdOf` for `bdlt::Datetime`.
`SimpleTypeIdOf<bdlt::DatetimeTz>`	Specialization of `SimpleTypeIdOf` for `bdlt::DatetimeTz`.
`UsesBslmaAllocator<bsl::pair<T1, T2>>`	Trait indicating `pair` uses `bslma` allocators when either element does.
`UsesBslmaAllocator`	Metafunction that is `true_type` if `TYPE` uses the `bslma` allocator idiom.
`Variant_AssignsFromType`	Determine whether `t_TYPE` assigns to a unique alternative of `t_VARIANT`.
`Variant_ConstructsFromType`	Determine whether `t_TYPE` constructs a unique alternative of `t_VARIANT`.
`Variant_ConvertsWithoutNarrowing<t_DEST, t_SOURCE, bsl::void_t<decltype(Variant_ArrayHelper<t_DEST>{{std::declval<t_SOURCE>()}})>>`	Determine whether `t_SOURCE` converts to `t_DEST` without narrowing.
`Variant_CountCVType`	Count occurrences of `t_TYPE` in `t_HEAD, t_TAIL...`, ignoring cv-quals.
`Variant_CountCVType<t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>`	Specialization for purposes of the sim_cpp11_features.pl script.
`Variant_CountType<t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>`	Specialization for purposes of the sim_cpp11_features.pl script.
`Variant_CountType`	Count how many times `t_TYPE` occurs among the listed alternatives.
`Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL...>>`	Determine whether `t_TYPE` occurs exactly once, ignoring cv-quals.
`Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL...>>`	Determine whether `t_TYPE` occurs exactly once in a `bsl::variant`.
`Variant_IsAlternativeConstructibleFrom`	Determine whether the unique best-match alternative is constructible.
`Variant_IsBitwiseMoveableAll`	This component-private metafunction is derived from `bsl::true_type` if all template arguments are bitwise moveable, and from `bsl::false_type` otherwise.
`Variant_IsCopyAssignableAll`	This component-private metafunction is derived from `bsl::true_type` if all template parameters are copy assignable, and `bsl::false_type` otherwise.
`Variant_IsCopyConstructibleAll`	This component-private metafunction is derived from `bsl::true_type` if all template parameters are copy constructible, and `bsl::false_type` otherwise.
`Variant_IsMoveAssignableAll`	This component-private metafunction is derived from `bsl::true_type` if all template parameters are move assignable, and `bsl::false_type` otherwise.
`Variant_IsMoveConstructibleAll`	This component-private metafunction is derived from `bsl::true_type` if all template parameters are move constructible, and `bsl::false_type` otherwise.
`Variant_IsSameReturnType`	Determine whether `t_VISITOR` yields `t_RET` for every alternative.
`Variant_ReturnValueHelper`	Component-private helper that detects a visitor `ResultType`.
`Variant_TypeToIndexImpl<t_INDEX, t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>`	Handle the case where `t_TYPE` was not found in the alternative list.
`Variant_UsesBslmaAllocatorAny`	This component-private metafunction is derived from `bsl::true_type` if at least one template argument uses an allocator, and from `bsl::false_type` otherwise.
`Variant_isAlternativeAssignableFrom`	Determine whether the unique best-match alternative is assignable.
`is_arithmetic`	Standard meta-function for determining arithmetic types.
`is_convertible`	Meta-function for detecting implicit convertibility between types.
`is_copy_constructible`	Meta-function for detecting copy-constructible types.
`is_empty`	Meta-function for detecting empty class types.
`is_enum`	Meta-function for detecting enumerated types.
`is_floating_point`	Meta-function for determining floating-point types.
`is_function`	Meta-function for detecting function types.
`is_fundamental`	Standard meta-function for detecting fundamental types.
`is_integral`	This `struct` template implements the `is_integral` meta-function defined in the C++11 standard to determine if the (template parameter) `t_TYPE` is an integral type.
`is_lvalue_reference`	Metafunction that is `true` if the (template parameter) `t_TYPE` is an lvalue reference type.
`is_polymorphic`	Meta-function for detecting polymorphic types.
`variant_size<variant<t_HEAD, t_TAIL...>>`	Provide the number of alternatives of a `bsl::variant` specialization.