bslalg.h

Go to the documentation of this file.

/// @file bslalg.h
///
///
/// @defgroup bslalg Package bslalg
/// @brief  Basic Standard Library ALgorithms (bslalg)
/// @addtogroup bsl
/// @{
/// @addtogroup bslalg
/// @{
/// * <a href="#bslalg-purpose"> Purpose</a>
/// * <a href="#bslalg-mnemonic"> Mnemonic </a>
/// * <a href="#bslalg-description"> Description </a>
///   * <a href="#bslalg-hierarchical-synopsis"> Hierarchical Synopsis </a>
///   * <a href="#bslalg-component-synopsis"> Component Synopsis </a>
///
/// # Purpose {#bslalg-purpose}
/// Provide algorithms and traits used by the BDE STL implementation.
///
/// # Mnemonic {#bslalg-mnemonic}
/// Basic Standard Library ALgorithms (bslalg)
///
/// # Description {#bslalg-description}
/// This package provides facilities for implementing higher-level
/// components (in particular, the standard library containers).  The facilities
/// fall into three broad classes:
///
///  * Utilities that provide efficient implementations of primitive operations on
///    generic data types (e.g., construction, copy-construction), optimized based
///    on the exposed traits of the type (e.g., bitwise-copyable, uses-allocator).
/// 
///  * Primitive data types and fundamental algorithms that form the basis of
///    standard library containers (e.g., linked lists, hash tables, Red/Black
///    trees and deques).
/// 
///  * Legacy traits types used to tag user-defined (client) types according to
///    properties such as whether they use a memory allocator to supply memory
///    resources, have a trivial default constructor, are POD types, etc.  These
///    traits types have been superseded by the traits in the 'bslmf' package, and
///    are implemented in terms of 'bslmf'.
/// 
///
/// ## Hierarchical Synopsis {#bslalg-hierarchical-synopsis}
///
/// The 'bslalg' package currently has 44 components having 7 levels of physical
/// dependency.  The list below shows the hierarchical ordering of the components.
/// The order of components within each level is not architecturally significant,
/// just alphabetical.
/// @code
///  7. bslalg_dequeprimitives
///     bslalg_hashtableimputil
///     bslalg_rbtreeutil
///
///  6. bslalg_arrayprimitives
///     bslalg_hashtableanchor
///
///  5. bslalg_bidirectionalnode
///     bslalg_constructorproxy
///     bslalg_dequeiterator
///
///  4. bslalg_autoarraymovedestructor
///     bslalg_hashtablebucket
///     bslalg_scalarprimitives
///     bslalg_selecttrait                                  !DEPRECATED!
///     bslalg_typetraits                                   !DEPRECATED!
///
///  3. bslalg_autoarraydestructor
///     bslalg_autoscalardestructor
///     bslalg_bidirectionallinklistutil
///     bslalg_nothrowmovableutil
///     bslalg_rbtreeanchor
///     bslalg_typetraitbitwisecopyable                     !DEPRECATED!
///     bslalg_typetraitbitwiseequalitycomparable           !DEPRECATED!
///     bslalg_typetraitbitwisemoveable                     !DEPRECATED!
///     bslalg_typetraithaspointersemantics                 !DEPRECATED!
///     bslalg_typetraithasstliterators                     !DEPRECATED!
///     bslalg_typetraithastrivialdefaultconstructor        !DEPRECATED!
///     bslalg_typetraitpair                                !DEPRECATED!
///     bslalg_typetraitusesbslmaallocator                  !DEPRECATED!
///
///  2. bslalg_arraydestructionprimitives
///     bslalg_bidirectionallink
///     bslalg_containerbase
///     bslalg_dequeimputil
///     bslalg_functoradapter
///     bslalg_hashutil
///     bslalg_hasstliterators
///     bslalg_hastrait                                     !DEPRECATED!
///     bslalg_nothrowmovablewrapper
///     bslalg_numericformatterutil
///     bslalg_rangecompare
///     bslalg_rbtreenode
///     bslalg_scalardestructionprimitives                  !DEPRECATED!
///     bslalg_swaputil
///     bslalg_synththreewayutil
///     bslalg_typetraitnil                                 !DEPRECATED!
///
///  1. bslalg_arrayprimitives_cpp03                                     !PRIVATE!
///     bslalg_dequeprimitives_cpp03                                     !PRIVATE!
/// @endcode
///
/// ## Component Synopsis {#bslalg-component-synopsis}
///
///  @ref bslalg_arraydestructionprimitives :
///       Provide primitive algorithms that destroy arrays.
/// 
///  @ref bslalg_arrayprimitives :
///       Provide primitive algorithms that operate on arrays.
/// 
///  @ref bslalg_arrayprimitives_cpp03 :                                     !PRIVATE!
///       Provide C++03 implementation for bslalg_arrayprimitives.h
/// 
///  @ref bslalg_autoarraydestructor :
///       Provide a proctor for destroying arrays.
/// 
///  @ref bslalg_autoarraymovedestructor :
///       Provide a proctor for destroying arrays.
/// 
///  @ref bslalg_autoscalardestructor :
///       Provide a proctor for destroying an object.
/// 
///  @ref bslalg_bidirectionallink :
///       Provide a basic link type for building doubly-linked lists.
/// 
///  @ref bslalg_bidirectionallinklistutil :
///       Provide utilities to maintain bidirectional list data structures.
/// 
///  @ref bslalg_bidirectionalnode :
///       Provide a node holding a value in a doubly-linked list.
/// 
///  @ref bslalg_constructorproxy :
///       Provide a proxy for constructing and destroying objects.
/// 
///  @ref bslalg_containerbase :
///       Provide a wrapper for STL allocators, for container use.
/// 
///  @ref bslalg_dequeimputil :
///       Provide basic parameters and primitive data structures for deques.
/// 
///  @ref bslalg_dequeiterator :
///       Provide a primitive iterator over deque data structures.
/// 
///  @ref bslalg_dequeprimitives :
///       Provide primitive algorithms that operate on deques.
/// 
///  @ref bslalg_dequeprimitives_cpp03 :                                     !PRIVATE!
///       Provide C++03 implementation for bslalg_dequeprimitives.h
/// 
///  @ref bslalg_functoradapter :
///       Provide an utility that adapts callable objects to functors.
/// 
///  @ref bslalg_hashtableanchor :
///       Provide a type holding the constituent parts of a hash table.
/// 
///  @ref bslalg_hashtablebucket :
///       Provide a bucket representation for hash table data structures.
/// 
///  @ref bslalg_hashtableimputil :
///       Provide algorithms for implementing a hash table.
/// 
///  @ref bslalg_hashutil :
///       Provide a utility of hash functions.
/// 
///  @ref bslalg_hasstliterators :
///       Provide a tag type used to detect STL-like iterators traits.
/// 
///  @ref bslalg_hastrait :                                     !DEPRECATED!
///       Provide a meta-function to detect if a type has a given trait.
/// 
///  @ref bslalg_nothrowmovableutil :
///       Provide a wrapper that asserts a noexcept move constructor.
/// 
///  @ref bslalg_nothrowmovablewrapper :
///       Provide a wrapper that asserts a noexcept move constructor.
/// 
///  @ref bslalg_numericformatterutil :
///       Provide a utility for formatting numbers into strings.
/// 
///  @ref bslalg_rangecompare :
///       Provide algorithms to compare iterator-ranges of elements.
/// 
///  @ref bslalg_rbtreeanchor :
///       Encapsulate root, first, and last nodes of a tree with a count.
/// 
///  @ref bslalg_rbtreenode :
///       Provide a base class for a red-black binary tree node.
/// 
///  @ref bslalg_rbtreeutil :
///       Provide a suite of primitive algorithms on red-black trees.
/// 
///  @ref bslalg_scalardestructionprimitives :                  !DEPRECATED!
///       Provide primitive algorithms that destroy scalars.
/// 
///  @ref bslalg_scalarprimitives :
///       Provide primitive algorithms that operate on single elements.
/// 
///  @ref bslalg_selecttrait :                                  !DEPRECATED!
///       Provide a meta-function to select a suitable trait on a type.
/// 
///  @ref bslalg_swaputil :
///       Provide a simple to use `swap` algorithm.
/// 
///  @ref bslalg_synththreewayutil :
///       Provide implementation utilities for `operator<=>`.
/// 
///  @ref bslalg_typetraitbitwisecopyable :                     !DEPRECATED!
///       Provide a trait to mark classes as bit-wise copyable.
/// 
///  @ref bslalg_typetraitbitwiseequalitycomparable :           !DEPRECATED!
///       Provide a trait to mark classes as bit-wise eq.-comparable.
/// 
///  @ref bslalg_typetraitbitwisemoveable :                     !DEPRECATED!
///       Provide a trait to mark classes as bit-wise moveable.
/// 
///  @ref bslalg_typetraithaspointersemantics :                 !DEPRECATED!
///       Provide a trait to mark classes as having pointer semantics.
/// 
///  @ref bslalg_typetraithasstliterators :                     !DEPRECATED!
///       Provide a trait to mark classes as having STL-like iterators.
/// 
///  @ref bslalg_typetraithastrivialdefaultconstructor :        !DEPRECATED!
///       Provide a trait to mark classes as having a trivial default ctor.
/// 
///  @ref bslalg_typetraitnil :                                 !DEPRECATED!
///       Provide a trait to mark classes as having no other traits.
/// 
///  @ref bslalg_typetraitpair :                                !DEPRECATED!
///       Provide a trait to mark classes as similar to `std::pair`.
/// 
///  @ref bslalg_typetraits :                                   !DEPRECATED!
///       Provide compile-time traits that can be associated with types.
/// 
///  @ref bslalg_typetraitusesbslmaallocator :                  !DEPRECATED!
///       Provide a trait to mark types that use `bslma` allocators.
///
/// @}
/** @} */