Name |
Description |
AddPointer_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_TYPE. |
AddReference
|
This meta‐function class defines a typedef, Type, that is an alias for a reference to the parameterized t_TYPE. References to cv‐qualified void will produce the original void type and not a reference (see specializations below). References‐to‐references "collapse" to produce an alias to the original reference type, which is the revised rule according to the C++11 standard. Note that there is no requirement that the parameterized t_TYPE be a complete type. |
ArrayToConstPointer
|
Meta‐function mapping an array type to a const pointer type. |
ArrayToPointer
|
Meta‐function mapping an array type to a pointer type. |
ConstForwardingType
|
DEPRECATED: Use ForwardingType instead. |
DetectNestedTrait
|
This struct template metafunction detects whether the specified t_TRAIT parameter is associated with the specified t_TYPE parameter using the nested type trait mechanism. This trait derives from bsl::true_type if and only if t_TYPE is a class type that associated with the specified trait using the BSLMF_NESTED_TRAIT_DECLARATION macro, and from bsl::false_type otherwise. Users should not specialize this trait directly for their types, but should always use the macro to make a nested trait association. |
EnableIf
|
This struct template implements a meta‐function that provides a typedef type that is an alias to the (template parameter) t_TYPE if the (template parameter) t_COND is true; otherwise, type is not provided. If t_TYPE is not specified, it is set to void. Note that this generic default template provides type for when t_COND is true; a template specialization is provided (below) that omits type for when t_COND is false. |
FloatingTypeStructuralTraits
|
This is the primary template declaration for bslmf::FloatingTypeStructuralTraits, which is never defined. |
ForwardingRefType
|
This template metafunction has a member Type computed such that, for a specified t_TYPE parameter, a function with argument of t_TYPE can be called efficiently from another function (e.g., a wrapper) by declaring the corresponding parameter of the other wrapper as 'typename ForwardingRefType<t_TYPE>::Type'. The Type member is computed to minimize the number of expensive copies while forwarding the arguments as faithfully as possible. |
ForwardingRefTypeUtil
|
Provide a namespace for the forwardToTarget function. |
ForwardingRefType_Category
|
This component‐private struct provides a namespace for the type dispatch category enumeration values. |
ForwardingRefType_Dispatch
|
This component‐private class template is a metafunction whose value member is the forwarding category for the specified t_TYPE. |
ForwardingType
|
This template metafunction has a member Type computed such that, for a specified t_TYPE parameter, a function with argument of t_TYPE can be called efficiently from another function (e.g., a wrapper) by declaring the corresponding parameter of the other wrapper as 'typename ForwardingType<t_TYPE>::Type'. The Type member is computed to minimize the number of expensive copies while forwarding the arguments as faithfully as possible. |
ForwardingTypeUtil
|
Provide a namespace for the forwardToTarget function. |
ForwardingType_Category
|
This component‐private struct provides a namespace for thpe type dispatch category enumeration values. |
ForwardingType_Dispatch
|
This component‐private class template is a metafunction whose value member is the forwarding category for the specified t_TYPE. |
ForwardingType_Imp<Signaler_NotArg, 5>
|
Rvalue of user type (i.e., class or union) is forwarded as a const reference. |
FunctionPointerCLinkage
|
C function pointer linkage tag. |
FunctionPointerCPlusPlusLinkage
|
C++ function pointer linkage tag. |
FunctionPointerTraits
|
This class gives information about the specified t_PROTOTYPE. The general definition gives no information, but specializations for function pointers types define nested types ResultType, ArgumentList, and Linkage. |
HasPointerSemantics
|
Metafunction indicating whether the (template parameter) t_TYPE has pointer‐like semantics. |
If
|
This meta‐function selects t_IF_TRUE_TYPE if t_CONDITION is non‐zero. and t_IF_FALSE_TYPE otherwise. |
IntegerSequence
|
This class template represents a compile‐time sequence of integers. When passed as an argument to a function template, the specified parameter pack t_INTS can be deduced and used a in pack expansion. |
InvokeResultDeductionFailed
|
When invoke_result cannot deduce the actual return type of a functor (in C++03 mode), it yields this type as a placeholder. The advantage of using this placeholder instead of a compilation failure (e.g., 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. Since InvokeResultDeductionFailed is a return type, it must be convertible from the actual return type; this conversion is accomplished by means of a constructor that makes it convertible from any type. |
InvokeResult_AddCVRef
|
Starting with type, t_UNQUAL_TYPE, generate a new type by applying the following steps in order: |
InvokeResult_BaseCalcUtil
|
Forward declaration |
InvokeResult_FuncPtrImp
|
Forward declaration |
InvokeResult_FunctorImp
|
Forward declaration |
InvokeResult_Index
|
Metafunction helpers for deducing the return type of an expression. |
InvokeResult_MemFuncPtrImp
|
Forward declaration |
InvokeResult_MemFuncPtrImpDispatch
|
Forward declaration. |
InvokeResult_MemObjPtrImp
|
Forward declaration |
InvokeResult_MemObjPtrImpDispatch
|
Forward declaration. |
InvokeResult_MemPtrArgQualifiers
|
This metafunction determines which cv qualifiers and reference qualifiers should be propagated from the first argument of invoke_result. This primary template is instantiated when t_ARG_TYPE is the same or is derived from t_MEMOF_CLASS. The constant k_IS_LVALUE is true iff t_ARG_TYPE is an lvalue reference; the constant k_IS_CONST is true iff t_ARG_TYPE is const‐qualified; and the constant k_IS_VOLATILE is true iff t_ARG_TYPE is volatile‐qualified. |
InvokeResult_Type
|
Metafunction to convert a type index back to a type. For each specialization of this struct, the type member will be the type corresponding to index. For example, if index is e_UCHAR, then InvokeResult_Type<index>::type is unsigned char. |
InvokeResult_VoidChecker
|
Empty type used to detect void expressions. The size of this type is the same as bslmf::Tag<1>. |
IsAccessibleBaseOf
|
This struct template provides a type trait to determine if one class is an accessible base class of another class. Note that, while similar to std::is_base_of, when the derived relationship is via private, protected, or ambiguous inheritance IsAccessibleBaseOf evaluates to false. |
IsArray
|
This struct template implements a meta‐function to determine if the (template parameter) t_TYPE is an array type. This struct derives from bsl::true_type if the t_TYPE is an array type, and bsl::false_type otherwise. |
IsBitwiseCopyable
|
This struct template provides a meta‐function to determine whether the (template parameter) t_TYPE is bitwise copyable. |
IsBitwiseEqualityComparable
|
This trait struct is a metafunction that determines whether the specified parameter t_TYPE is bitwise EqualityComparable. If IsBitwiseEqualityComparable<t_TYPE> is derived from true_type then t_TYPE is bitwise EqualityComparable. Otherwise, bitwise equality comparability cannot be inferred for t_TYPE. This trait can be associated with a bitwise EqualityComparable user‐defined class by specializing this class or by using the BSLMF_NESTED_TRAIT_DECLARATION macro. |
IsBitwiseMoveable
|
Trait metafunction that determines whether the specified parameter t_TYPE is bitwise moveable. If IsBitwiseMoveable<t_TYPE> is derived from bsl::true_type then t_TYPE is bitwise moveable. Otherwise, bitwise moveability cannot be inferred for t_TYPE. This trait can be associated with a bitwise moveable user‐defined class by specializing this class or by using the BSLMF_NESTED_TRAIT_DECLARATION macro. |
IsBitwiseMoveable_Imp<allocator<unsigned long>>
|
Core implementation of the IsBitwiseMoveable trait. A class is detected as being bitwise moveable iff it is trivially copyable or it has a nested trait declaration for the IsBitwiseMoveable trait. In C++03 however, detection of trivially copyable classes is imperfect and depends on programmer intervention. As many empty classes (including standard classes like std::less<T> 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. See component‐level documentation for this component for more details on this heuristic and how to avoid false positives. |
IsClass
|
This meta‐function derives from bsl::true_type if the (template parameter) t_TYPE is a class type, or a reference to a class type, and from bsl::false_type otherwise. |
IsConvertible
|
This struct template implements a meta‐function to determine if the (template parameter) t_FROM_TYPE is convertible to the (template parameter) t_TO_TYPE. This struct derives from bsl::true_type if the t_FROM_TYPE is convertible to t_TO_TYPE, and from bsl::false_type otherwise. Note that both t_FROM_TYPE and t_TO_TYPE should be complete types, arrays of unknown bound, or (possibly cv‐qualified) void types. |
IsConvertibleToAny
|
This struct template implements a meta‐function to determine if the (template parameter) t_TYPE is convertible to any other type. This struct derives from bsl::true_type if t_TYPE is convertible to any type, and bsl::false_type otherwise. |
IsConvertible_CheckComplete
|
Private helper for IsConvertible complete‐type checks. |
IsEnum
|
This struct provides a meta‐function that computes, at compile time, whether the (template parameter) t_TYPE is an enumerated type. It derives from bsl::true_type if t_TYPE is an enumerated type, and from bsl::false_type otherwise. |
IsFunctionPointer
|
This template determines if the specified t_PROTOTYPE is a free (i.e., non‐member) function pointer. value is defined as 1 if the specified t_PROTOTYPE is a function pointer type, and a zero value otherwise. |
IsFundamental
|
This struct template implements a meta‐function for checking if a type is fundamental, or a reference to a fundamental type. The static constant value member will be 1 if t_TYPE is fundamental and 0 otherwise. |
IsFundamental_Imp<bsl::nullptr_t>
|
This partial specialization of IsFundamental_Imp derives from bsl::true_type for when the (template parameter) t_TYPE is void. |
IsMemberFunctionPointer
|
This template determines if the specified t_PROTOTYPE is a member function pointer. value is defined as 1 if the specified t_PROTOTYPE is a member function, and a zero value otherwise. |
IsNil
|
Metafunction that is true for Nil and false for all other types. |
IsPair
|
Metafunction that is false for all types except bsl::pair specializations. |
IsPointer
|
This struct template implements a meta‐function to determine if the (template parameter) t_TYPE is a pointer type. This struct derives from bsl::true_type if the t_TYPE is a pointer type (but not a pointer to non‐static member), and bsl::false_type otherwise. |
IsPolymorphic
|
This struct template implements a meta‐function to determine if the (template parameter) t_TYPE is a (possibly cv‐qualified) polymorphic type. This struct derives from bsl::true_type if the t_TYPE is a polymorphic type, and bsl::false_type otherwise. |
IsReferenceWrapper
|
This struct template implements a boolean metafunction used to detect if the specified t_TYPE is a reference wrapper. Clients may specialize this struct template to inherit from bsl::true_type for t_TYPE types that are specializations of bsl::reference_wrapper. The behavior is undefined if any other specialization of this struct template is defined. Note that this struct template |
IsSame
|
This struct template implements a meta‐function to determine if the (template parameter) t_TYPE1 and the (template parameter) t_TYPE2 are the same. This struct derives from bsl::true_type if t_TYPE1 and t_TYPE2 are the same, and bsl::false_type otherwise. |
IsTransparentPredicate
|
This struct template implements a meta‐function to determine whether the (template parameter) t_COMPARATOR is transparent (has a publicly accessible member that is a type named is_transparent). This generic default template derives from bsl::false_type. Template specializations are provided (below) that derive from bsl::true_type. |
IsTriviallyCopyableCheck
|
This struct exists to return the same value as is_trivially_copyable and is intended to never be specialized. The purpose of using it is to perform the following static assert that the bsl and std versions of is_trivially_copyable are in sync. |
IsTriviallyCopyable_DetectTrait
|
This struct template implements a meta‐function to determine whether the (non‐cv‐qualified) (template parameter) t_TYPE has been explicitly tagged with the trivially copyable trait. If the flag t_K_INTRINSIC is true then the compiler has already determined that t_TYPE is trivially copyable without user intervention, and the check for nested traits can be optimized away. |
IsTriviallyCopyable_Intrinsic
|
This struct template implements a meta‐function to determine whether the (non‐cv‐qualified) (template parameter) t_TYPE is trivially copyable. |
IsTriviallyDefaultConstructible_DetectTrait
|
This struct template implements a meta‐function to determine whether the (non‐cv‐qualified) (template parameter) t_TYPE has been explicitly tagged with the trivially default constructible trait. If the flag t_K_INTRINSIC is true then the compiler has already determined that t_TYPE is trivially default constructible without user intervention, and the check for nested traits can be optimized away. |
IsVoid
|
This struct template implements a meta‐function to determine if the (template parameter) t_TYPE is the (possibly cv‐qualified) void type. This struct derives from bsl::true_type if t_TYPE is the void type, and bsl::false_type otherwise. |
MakeIntegerSequence_ConcatUtil
|
This component‐private class template provides a specialization that concatenates two integer sequences. This template is not defined unless the (template parameter) types t_S1 and t_S2 are specializations of the class template bslmf::IntegerSequence. |
MakeIntegerSequence_Impl<t_T, bsl::integral_constant<std::size_t, 0>>
|
This partial specialization of the bslmf::MakeIntegerSequence_Impl meta‐function is a recursion break condition for an empty integer sequence. |
MakeIntegerSequence_Impl<t_T, bsl::integral_constant<std::size_t, 1>>
|
This partial specialization of the bslmf::MakeIntegerSequence_Impl meta‐function is a recursion break condition for an integer sequence having the length 1. |
MakeIntegerSequence_Impl<t_T, bsl::integral_constant<std::size_t, 2>>
|
This partial specialization of the bslmf::MakeIntegerSequence_Impl meta‐function is a recursion break condition for an integer sequence having the length 2. |
MakeIntegerSequence_Impl<t_T, bsl::integral_constant<std::size_t, 3>>
|
This partial specialization of the bslmf::MakeIntegerSequence_Impl meta‐function is a recursion break condition for an integer sequence having the length 3. |
MakeIntegerSequence_Impl<t_T, bsl::integral_constant<std::size_t, 4>>
|
This partial specialization of the bslmf::MakeIntegerSequence_Impl meta‐function is a recursion break condition for an integer sequence having the length 4. |
MakeIntegerSequence_Impl<t_T, bsl::integral_constant<std::size_t, 5>>
|
This partial specialization of the bslmf::MakeIntegerSequence_Impl meta‐function is a recursion break condition for an integer sequence having the length 5. |
MakeIntegerSequence_Impl<t_T, bsl::integral_constant<std::size_t, 6>>
|
This partial specialization of the bslmf::MakeIntegerSequence_Impl meta‐function is a recursion break condition for an integer sequence having the length 6. |
MakeIntegerSequence_Impl<t_T, bsl::integral_constant<std::size_t, 7>>
|
This partial specialization of the bslmf::MakeIntegerSequence_Impl meta‐function is a recursion break condition for an integer sequence having the length 7. |
MakeIntegerSequence_Impl<t_T, bsl::integral_constant<std::size_t, 8>>
|
This partial specialization of the bslmf::MakeIntegerSequence_Impl meta‐function is a recursion break condition for an integer sequence having the length 8. |
MatchAnyType
|
Any type can be converted into this type. |
MatchArithmeticType
|
This copy‐constructible mechanism can be used as a formal parameter for functions where an arithmetic type can be confused with an iterator type. A copy‐constructible mechanism is needed so that such objects can be used as function arguments. |
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. |
MemberFunctionPointerTraits_ClassType
|
This class determines whether the specified t_PROTOTYPE is a const, volatile or noexcept member function of the specified t_TYPE. The Type member will be a correctly const and/or volatile qualified version of t_TYPE. This metafunction is necessary because some old compilers do not correctly dispatch to the correct partial specialization of MemberFunctionPointerTraits_Imp based on cv‐qualification of the member‐function pointer. |
MemberFunctionPointerTraits_Imp<t_PROTOTYPE, t_BSLMF_RETURN const volatile(t_TYPE::*)(t_ARGS...) noexcept>
|
Specialization to determine the traits of member functions. A modern compiler will match only non‐cv member functions, but some older compilers might match this to any member function. |
MemberPointerTraits
|
This utility struct template provides the following nested typedefs:: ClassType: The type of the class for which the specified t_TYPE is: a pointer to member object.: MemberType: The type of the member object of the class for which the: specified t_TYPE is a pointer to member object. These typedefs will only be defined if t_TYPE is a |
MemberPointerTraits_Imp<t_MEMBER_TYPEt_CLASS_TYPE::*>
|
|
MetaInt
|
Instantiating this template produces a distinct type for each non‐negative integer value. This template has been deprecated in favor of the standard integral_constant template. |
MovableRefUtil
|
This struct provides a collection of utility functions operating on objects of type MovableRef<t_TYPE>. The primary use of these utilities is to create a consistent notation for using the C++03 MovableRef<t_TYPE> objects and the C++11 t_TYPE&& r‐value references. |
MovableRefUtil_AddLvalueReference
|
forward declaration |
MovableRefUtil_AddMovableReference
|
forward declaration |
MovableRefUtil_Decay
|
forward declaration |
MovableRefUtil_PropertyTraits
|
forward declaration |
MovableRefUtil_RemoveReference
|
forward declaration |
MovableRef_Helper
|
forward declaration |
NestedTraitDeclaration
|
Class t_TYPE will be convertible to NestedTraitDeclaration<t_TYPE,t_TRAIT,true> if t_TRAIT is associated with t_TYPE using the BSLMF_NESTED_TRAIT_DECLARATION macro. Nested trait detection depends on t_COND being true. If t_COND is false, the nested trait detection will not see the conversion it is looking for and will not associate t_TRAIT with t_TYPE. This feature is used by BSLMF_NESTED_TRAIT_DECLARATION_IF to turn a trait on or off depending on a compile‐time condition (usually another trait). |
Nil
|
This struct is empty and represents a nil type. |
NthParameter
|
Metafunction to compute the specified t_N`th element of the specified `t_PARAMS template parameter pack. The Type nested typedef will match the t_N`th element of `t_PARAMS, where t_N is zero‐based (so that an t_N of zero corresponds to the first parameter. |
NthParameter_Sentinel
|
Sentinel type used internally by NthParameter (declared but not defined). |
RemoveCvq
|
This class implements a meta‐function for stripping top‐level const/volatile qualifiers from it's parameter type. |
RemoveReference
|
This struct template implements a meta‐function to remove the reference‐ness from the (template parameter) t_TYPE. Note that although this struct is functionally equivalent to bsl::remove_reference, the use of bsl::remove_reference should be preferred. |
ResultType
|
Metafunction to return the result type of the specified functor type t_FUNC. The nested type is identical to t_FUNC::result_type if such a type exists; otherwise, it is identical to t_FUNC::ResultType if that type exists; otherwise, it is identical to the t_FALLBACK template parameter if it was specified; otherwise, it is undefined. |
ResultType_BdeIdiom
|
Metafunction to detect the BDE ResultType idiom as part of the implementation of bslmf::ResultType. This struct is instantiated when t_FUNC::result_type doesn't exist. This primary template is matched when t_FUNC::ResultType also does not exist. The t_FALLBACK type, if any, is produced. |
ResultType_Fallback
|
Metafunction that defines type to be the specified t_FALLBACK type unless t_FALLBACK is bslmf::Nil. |
SelectTrait
|
Instantiate each specified (template parameter) t_TRAIT1 to t_TRAIT9 metafunction using the specified (template parameter) t_TYPE. Inherit from SelectTraitCase<TRAITx>, where x is 1 if t_TRAIT1<t_TYPE>::value is true, 2 if t_TRAIT2<t_TYPE>::value is true, etc.. If none of the traits evaluates to true, then inherit from SelectTraitCase<>, which means that none of the traits match. |
SelectTraitCase
|
This template expresses a class that is unique for the specified (template parameter) t_TRAIT metafunction. An instantiation of this template is the "compile‐time return value" of SelectTrait (see below). SelectTraitCase acts as a sort of compile‐time pointer‐to‐metafunction that holds the identity of a metafunction similar to the way a pointer‐to‐function holds (at run‐time) the identity of a function. As in the pointer‐to‐function case, a SelectTraitCase can also be used indirectly to evaluate t_TRAIT (at compile time). Also note that, when SelectTraitCase is specialized with the default t_TRAIT type parameter, SelectTrait_False, it essentially means that none of the traits specified to SelectTrait match. |
SelectTrait_False
|
Metafunction that always returns false. |
Switch
|
This meta‐function, parameterized by an integral t_SWITCH_SELECTOR and types t_T0 up to t_T9, provides a single type alias, Type, which resolves, through specialization for a particular value N of t_SWITCH_SELECTOR, to the type TN, or to Nil if t_SWITCH_SELECTOR is negative or larger than the number of template arguments provided for the types. |
Tag
|
This template class is never intended to produce a run‐time instance. 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). Note that in case of overflow on Linux 64‐bit machines, we split the size into 2 data members. |
TypeList
|
Compile‐time list of zero or more types. |
TypeListTypeAt
|
This template is specialized below to return the type the t_INDEX`th member of the typelist `t_LIST. If 0 > t_INDEX <= t_LIST::LENGTH then Type will be defined as the type of the member. Note that t_INDEX is relative to 1. |
TypeRep
|
Generate a reference to t_TYPE for use in meta‐functions. |
UsesAllocatorArgT
|
User‐specialized trait type indicating that the constructor of t_TYPE can be invoked using bsl::allocator_arg as its first argument and an allocator object as its second argument. |
Util
|
This struct provides several functions that are specified in the <utility> header of the C++ Standard, in order to support the bsl library implementation without cycles into the native standard library, and on platforms with only C++03 compilers available, where library features may be emulated. |
VoidType
|
Metafunction that always yields type void for any well‐formed list of type parameters. This metafunction is useful when using SFINAE to probe for well‐formed types. |