Metafunction representing a compile‐time constant of the specified (template parameter) t_TYPE with the specified (template parameter) t_VALUE.

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.

Created with MrDocs