ArrayDestructionPrimitives | This struct provides a namespace for a suite of utility functions that destroy arrays of elements of the parameterized type TARGET_TYPE. Depending on the traits of TARGET_TYPE, the destructor may be invoked, or not (optimized away by no-op). |
ArrayPrimitives | This struct provides a namespace for a suite of independent utility functions that operate on arrays of elements of parameterized type TARGET_TYPE. Depending on the traits of TARGET_TYPE, the default and copy constructors, destructor, assignment operators, etcetera may not be invoked, optimized away by no-op or bit-wise move or copy. |
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. |
AutoArrayDestructor | This class provides a specialized proctor object that, upon destruction and unless the release method has been called, destroys the elements in a segment of an array of parameterized type OBJECT_TYPE. The elements destroyed are delimited by the "guarded" range [ begin(), end() )]. |
AutoArrayMoveDestructor | This class provides a specialized proctor object that, upon destruction and unless the release method has been called, bit-wise moves the elements in a segment of an array of parameterized OBJECT_TYPE back to some destination, and destroys some other elements in an adjacent segment of the same array. The elements destroyed are delimited by the range [ begin(), middle() )] and those moved to destination() and in the range [ middle(), end() )]. Note that, once constructed, begin() and end() remain fixed. As the guard advances, middle() and destination() move, reflecting the successful transfer of data between the moving range and the destination. |
AutoScalarDestructor | This class provides a specialized proctor object that, upon destruction and unless the release method is called, destroys the guarded object of the parameterized OBJECT_TYPE. |
BidirectionalLink | This POD-like class describes a node suitable for use in a doubly- linked (bidirectional) list, holding the addresses of the preceding and succeeding nodes, either or both of which may be 0. This class is "POD-like" to facilitate efficient allocation and use in the context of a container implementations. In order to meet the essential requirements of a POD type, this class does not declare a constructor or destructor. However its data members are private. It satisfies the requirements of a trivial type and a standard layout type defined by the C++11 standard. Note that this type does not contain any "payload" member data: Clients creating a doubly-linked list of data must define an appropriate node type that incorporates BidirectionalLink (generally via inheritance), and that holds the "value" of any data stored in that node. |
BidirectionalLinkListUtil | This struct provides a namespace for utility functions that manipulate linked lists based on bslalg::BidirectionalLink nodes, including insertion, removal, and splicing. |
BidirectionalNode | This POD-like class describes a node suitable for use in a doubly-linked list of values of the template parameter type VALUE. This class is a "POD-like" to facilitate efficient allocation and use in the context of a container implementation. In order to meet the essential requirements of a POD type, this class does not define a constructor or destructor. The manipulator, value, returns a modifiable reference to d_value so that it may be constructed in-place by the appropriate bsl::allocator_traits object. |
ConstructorProxy | This class acts as a proxy for constructing and destroying an object of parameterized OBJECT_TYPE, where OBJECT_TYPE may or may not use a bslma allocator for supplying memory. The constructors for this proxy class take a bslma::Allocator *. If OBJECT_TYPE has the bslma::UsesBslmaAllocator trait declared, then the supplied allocator will be used to construct the proxied object. Otherwise, the allocator is ignored. |
ConstructorProxy_AllocatorType | Metafunction to determine the allocator type for a specified template parameter TYPE using the specified template parater AAMODEL for constructors. This primary template yields a nested type of bsl::polymorphic_allocator, which is the most permisive type to use as a constructor parameter, and an ArgType allocator constructor argument that is a wrapper around polymorphic_allocator that tolerates being constructed with a null pointer. However, if AAMODEL is AAModelNone or AAModelStl, the allocator constructor argument is ignored and not passed to the proxied object. |
ConstructorProxy_PolymorphicAllocator | Wrapper around bsl::polymorphic_allocator that can tolerate being constructed with a null pointer. |
ContainerBase | Allocator proxy class for STL-style containers. Provides access to the allocator. Implements the entire STL allocator interface, redirecting allocation and deallocation calls to the proxied allocator. One of two possible base classes is chosen depending on whether ALLOCATOR is an empty class. |
ContainerBase_EmptyBase | One of two possible base classes for ContainerBase. This class is for stateless allocators (i.e., that have size 0), including std::allocator (but not bsl::allocator). Provides access to the allocator. |
ContainerBase_NonEmptyBase | One of two possible base classes for ContainerBase. This class should be used only for allocators with size > 0 (Inheritance from this type can cause ambiguous conversions and should be avoided or insulated.) |
DequeImpUtil | This struct, parameterized by the VALUE_TYPE and a BLOCK_LENGTH, provides the various parameters of the deque implementation. |
DequeIterator | Implementation of a deque iterator, parameterized by the VALUE_TYPE, for a deque with the parameterized BLOCK_LENGTH, and suitable for use by the bslstl::RandomAccessIterator adapter. Note that BLOCK_LENGTH is the number of items of VALUE_TYPE within a block, not the size of a block in bytes. |
DequePrimitives | This struct provides a namespace for a suite of utility functions that operate on deques parameterized by the VALUE_TYPE and BLOCK_LENGTH. Depending on the traits of VALUE_TYPE, the default and copy constructors, destructor, assignment operators, etcetera may not be invoked, and instead the operation can be optimized using a no-op, bitwise move, or bitwise copy. |
DequePrimitives_DequeElementGuard | This class provides a specialized proctor object that, upon destruction and unless the release method has been called, destroys the elements in a segment of a deque of parameterized VALUE_TYPE. The elements destroyed are delimited by the "guarded" range [d_begin .. d_end)]. |
DequePrimitives_DequeEndpointProctor | This class implements a proctor that, upon destruction and unless its release method has previously been invoked, sets a deque endpoint (i.e., "start" or "finish" iterator) to a position within the deque. Both the endpoint and position are supplied at construction. See emplaceAndMoveToBack and emplaceAndMoveToFront for use cases. |
DequePrimitives_DequeMoveGuard | This class provides a guard object that, upon destruction and unless the release method has been called, uses moveBack or moveFront to move the "guarded" range [d_source_p .. d_source_p + d_size - 1] back to [d_destination_p .. d_destination_p + d_size -1]. |
DequePrimitives_ExternalDequeElementGuard | This class provides a specialized proctor object that, upon destruction and unless the release method has been called, destroys the elements in a segment of a bsl::deque of parameterized type VALUE_TYPE. The elements destroyed are delimited by the "guarded" range [*d_begin .. *d_end)]. Note that the range guarded by this class is dynamic and can be changed outside of this class. |
FunctorAdapter | This class provides a metafunction that defines an alias Type for the parameterized CALLABLE_OBJECT. Type is functor type that provides the same operation as the parameterized CALLABLE_OBJECT. Note that function pointers are supported through a specialization of this template. |
FunctorAdapter_FunctionPointer | This class provides a functor that delegates to the function referred to by a function pointer supplied on construction. Delegation is supported through the conversion operator, which implicitly returns a reference to the parameterized FUNCTION_POINTER. |
HasStlIterators | This class detects if the specified class TYPE has STL-like iterators. If the class TYPE provides STL-like iterators then HasStlIterators<TYPE>::value == true, and HasStlIterators<TYPE>::value == false otherwise. |
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. |
HashTableAnchor | This complex constrained in-core (value-semantic) attribute class characterizes the key data elements of a hash table. See the section information on the class attributes. Note that the class invariant is the identically the complex constraint of this component. |
HashTableBucket | |
HashTableImpUtil | This struct provides a namespace for a suite of utility functions for creating and manipulating a hash table. |
HashTableImpUtil_ExtractKeyResult | Metafunction that deduces the return type of KEY_CONFIG::extractKey. |
HashUtil | This struct provides a namespace for hash functions. |
NothrowMovableUtil | Namesapace for NothrowMovableWrapper traits and utilities. |
NothrowMovableUtil_Traits | Metafunction providing traits for NothrowMovableWrapper types. |
NothrowMovableWrapper | An object of this type wraps a value of the specified TYPE, and provides no other functionality other than returning the wrapped object. The move constructor is guaranteed not to throw, even if the move constructor for TYPE has no such guarantee. The user is thus asserting that the move constructor for the wrapped object will not throw, even if it is allowed to. Constraints: this class can be instantiated on object types only, i.e., not references, arrays, or function types (though function pointers are OK). |
NumericFormatterUtil | Namespace struct for free functions supporting to_chars. |
RangeCompare | This utility struct provides two static class methods, equal and lexicographical, for comparing two ranges of values. equal returns true if each element in one range has the same value as the corresponding element in the other range, and false otherwise. lexicographical returns 0 if the two ranges are equal, a positive value if the first range is greater than the second, and a negative value if the second range is greater than the first. A range is specified by a pair of beginning and ending iterators, with an optional length parameter. Additionally, an overload is provided for the equal class method that allows the end iterator for one range to be omitted. |
RbTreeAnchor | An RbTreeAnchor provides the addresses of the first and root nodes of a binary search tree. An RbTreeAnchor is similar to an in-core simply constrained (value-semantic) attribute class, except that it does not supply equality-comparison, copy-construction, and copy-assignment operations. Note that a node may not be copied because sentinel returns an address unique to each RbTreeAnchor object. |
RbTreeNode | This POD-like class describes a node suitable for use in a red-black binary search tree, holding the addresses of the parent, left-child, and right-child nodes (any of which may be 0), as well as a "color" (red or black). This class is a "POD-like" to facilitate efficient allocation and use in the context of a container implementation. In order to meet the essential requirements of a POD type, this class does not define a constructor or destructor. However its data members are private. Since this class will be aligned to a word boundary, a pointer type will be a multiple of 4. This class use this property to reduce its size by storing the color information in the least significant bit of the parent pointer. Note that this type does not contain any "payload" member data: Clients creating a red-black binary search tree must define an appropriate node type that incorporates RbTreeNode (generally via inheritance), and that holds the "key" value and any associated data. |
RbTreeUtil | This struct provides a namespace for a suite of utility functions that operate on elements of type RbTreeNode. |
RbTreeUtilTreeProctor | This class implements a proctor that, unless release is called, invokes the parameterized DELETER on each node in the tree supplied at construction. |
RbTreeUtil_Validator | This struct provides a namespace for auxiliary functions used to validate a red-black binary search tree. |
ScalarPrimitives | This struct provides a namespace for a suite of utility functions that operate on elements of a parameterized type TARGET_TYPE. If any of the ...Construct methods throws, then its target address is left uninitialized and there are no effects, unless otherwise mentioned in the documentation. |
SelectTrait | Select one trait out of several that the parameterized type T may possess. If T has the parameterized trait TRAIT1, then the nested Type is TRAIT1, else if T has an optionally parameterized TRAIT2, then Type is TRAIT2, etc. Also computes an integral selection constant and meta-value. If T has none of the parameterized TRAIT*, then the nested Type is TypeTraitNil. |
SwapUtil | This class provides a namespace for the swap utility method. |
SynthThreeWayUtil | "Exposition-only" part of bslstl_compare.h |
TypeTraitBitwiseCopyable | Objects of a type with this trait can be copied using memcpy. After such a bitwise copy, both the original and the copy are valid. Classes with this trait are assumed to have trivial (no-op) destructors and are assumed to be bitwise moveable (see the TypeTraitBitwiseMoveable trait). Undefined behavior may result if this trait is assigned to a type that allocates memory or other resources, uses virtual inheritance, or places pointers to itself within other data structures. Also, objects of a type with this trait can be destroyed by a no-op, i.e., not invoking the destructor, although it is safe to write zeros into the memory footprint of the object. |
TypeTraitBitwiseEqualityComparable | Objects of a type with this trait can be compared for equality using memcmp. If two objects compare equal, then memcmp returns 0, otherwise it returns non-zero. Classes with this traits are assumed to have no padding and to be bit-wise copyable (see the TypeTraitBitwiseCopyable trait). Undefined behavior may result if this trait is assigned to a type that does not have an operator== or whose operator== implementation may return different from comparing the footprints with memcmp . |
TypeTraitBitwiseMoveable | Objects of a type with this trait can be "moved" from one memory location to another using memmove or memcpy. Although the result of such a bitwise copy is two copies of the same object, this trait only guarantees that one of the copies can be destroyed. The other copy must be considered invalid and its destructor must not be called. Most types, even those that contain pointers, are bitwise moveable. Undefined behavior may result if this trait is assigned to a types that contains pointers to its own internals, use virtual inheritance, or places pointers to itself within other data structures. |
TypeTraitHasPointerSemantics | A type with this trait is said to have "pointer semantics". That is the type behaves as if it were a fundamental pointer type. The type must define(at a minimum) operator* and operator->. Note that simply providing the above operators does not imply that a type has pointer semantics. This trait is intended for "wrapper" types that behave as pointers. Some examples of such types include std::auto_ptr, and bslma::ManagedPtr. This trait is generally used by objects that invoke the wrapped type. |
TypeTraitHasStlIterators | A TYPE with this trait defines (at minimum) the nested types iterator and const_iterator and the functions begin() and end() having the standard STL semantics. |
TypeTraitHasTrivialDefaultConstructor | A TYPE with this trait has a trivial default constructor. Objects of a type with this trait can be default-initialized by simply writing zeros into the memory footprint of the object. Although it is possible for such a type not to be bitwise copyable, undefined behavior may result if this trait is assigned to such a type. (See the description of TypeTraitBitwiseCopyable.) |
TypeTraitNil | Nil trait -- every type has this trait. |
TypeTraitPair | A TYPE with this trait has two data members, first and second of types T::first_type and T::second_type, respectively. |
TypeTraitUsesBslmaAllocator | A TYPE with this trait uses an allocator derived from bslma::Allocator to supply memory. See documentation on the bslma_usesbslmaallocator trait for the requirements on a TYPE that has this trait. |