Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Boost.Container Header Reference

Header <boost/container/adaptive_pool.hpp>
Header <boost/container/allocator.hpp>
Header <boost/container/allocator_traits.hpp>
Header <boost/container/container_fwd.hpp>
Header <boost/container/deque.hpp>
Header <boost/container/pmr/deque.hpp>
Header <boost/container/devector.hpp>
Header <boost/container/pmr/devector.hpp>
Header <boost/container/flat_map.hpp>
Header <boost/container/pmr/flat_map.hpp>
Header <boost/container/flat_set.hpp>
Header <boost/container/pmr/flat_set.hpp>
Header <boost/container/list.hpp>
Header <boost/container/pmr/list.hpp>
Header <boost/container/map.hpp>
Header <boost/container/pmr/map.hpp>
Header <boost/container/new_allocator.hpp>
Header <boost/container/node_allocator.hpp>
Header <boost/container/node_handle.hpp>
Header <boost/container/options.hpp>
Header <boost/container/pmr/global_resource.hpp>
Header <boost/container/pmr/memory_resource.hpp>
Header <boost/container/pmr/monotonic_buffer_resource.hpp>
Header <boost/container/pmr/polymorphic_allocator.hpp>
Header <boost/container/pmr/pool_options.hpp>
Header <boost/container/pmr/resource_adaptor.hpp>
Header <boost/container/pmr/synchronized_pool_resource.hpp>
Header <boost/container/pmr/unsynchronized_pool_resource.hpp>
Header <boost/container/scoped_allocator.hpp>
Header <boost/container/scoped_allocator_fwd.hpp>
Header <boost/container/set.hpp>
Header <boost/container/pmr/set.hpp>
Header <boost/container/slist.hpp>
Header <boost/container/pmr/slist.hpp>
Header <boost/container/small_vector.hpp>
Header <boost/container/pmr/small_vector.hpp>
Header <boost/container/stable_vector.hpp>
Header <boost/container/pmr/stable_vector.hpp>
Header <boost/container/static_vector.hpp>
Header <boost/container/string.hpp>
Header <boost/container/pmr/string.hpp>
Header <boost/container/throw_exception.hpp>
Header <boost/container/uses_allocator.hpp>
Header <boost/container/uses_allocator_fwd.hpp>
Header <boost/container/vector.hpp>
Header <boost/container/pmr/vector.hpp>

  
    template<typename T,  NodesPerBlock = , 
              MaxFreeBlocks = , 
              OverheadPercent = > 
      class adaptive_pool;
    template<typename T,  NodesPerBlock = , 
              MaxFreeBlocks = , 
              OverheadPercent = , 
              Version = > 
      class private_adaptive_pool;
  }
}

  
    template<typename T,  Version = , 
              AllocationDisableMask = > 
      class allocator;
  }
}

  
    template<typename Allocator> struct allocator_traits;
  }
}

This header file forward declares the following containers:

Forward declares the following allocators:

Forward declares the following polymorphic resource classes:

And finally it defines the following types


  
    struct ordered_range_t;
    struct ordered_unique_range_t;
    struct default_init_t;

    static ordered_range_t ordered_range;
    static ordered_unique_range_t ordered_unique_range;
    static default_init_t default_init;
  }
}

  
    template<typename T, typename Allocator, typename Options> class deque;
    template<typename InputIterator>  (, );
    template<typename InputIterator, typename Allocator> 
       (, , );
  }
}

  
    
      template<typename T> struct deque_of;

      typedef boost::container::deque< polymorphic_allocator<  ;
    }
  }
}

  
    struct reserve_only_tag_t;
    struct reserve_uninitialized_t;
    struct review_implementation_t;

    template<typename T, typename A, typename Options> class devector;
  }
}

  
    
      template<typename T, typename GrowthPolicy = growth_factor_60> 
        struct devector_of;

      typedef boost::container::devector< polymorphic_allocator<  ;
    }
  }
}

  
    template<typename Key, typename T, typename Compare, 
             typename AllocatorOrContainer = new_allocator< > 
      class flat_map;
    template<typename Key, typename T, typename Compare, 
             typename AllocatorOrContainer = new_allocator< > 
      class flat_multimap;
    template<typename InputIterator>  (, );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (, , );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (, , , 
                );
    template<typename InputIterator> 
       (ordered_unique_range_t, , );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (ordered_unique_range_t, , , 
                );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (ordered_unique_range_t, , , 
                , );
    template<typename InputIterator> 
       (, );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (, , );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (, , , 
                     );
    template<typename InputIterator> 
       (ordered_range_t, , );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (ordered_range_t, , , 
                     );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (ordered_range_t, , , 
                     , );
  }
}

  
    
      template<typename Key, typename T, typename Compare> struct flat_map_of;
      template<typename Key, typename T, typename Compare> 
        struct flat_multimap_of;

      typedef boost::container::flat_map< polymorphic_allocator<  ;
      typedef boost::container::flat_multimap< polymorphic_allocator<  ;
    }
  }
}

  
    template<typename Key, typename Compare, 
             typename AllocatorOrContainer = new_allocator<> 
      class flat_set;
    template<typename Key, typename Compare, 
             typename AllocatorOrContainer = new_allocator<> 
      class flat_multiset;
    template<typename InputIterator>  (, );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (, , );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (, , , 
                );
    template<typename InputIterator> 
       (ordered_unique_range_t, , );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (ordered_unique_range_t, , , 
                );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (ordered_unique_range_t, , , 
                , );
    template<typename InputIterator> 
       (, );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (, , );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (, , , 
                     );
    template<typename InputIterator> 
       (ordered_range_t, , );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (ordered_range_t, , , 
                     );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (ordered_range_t, , , 
                     , );
  }
}

  
    
      template<typename Key, typename Compare> struct flat_set_of;
      template<typename Key, typename Compare> struct flat_multiset_of;

      typedef boost::container::flat_set< polymorphic_allocator<  ;
      typedef boost::container::flat_multiset< polymorphic_allocator<  ;
    }
  }
}

  
    template<typename T, typename Allocator> class list;
    template<typename InputIterator>  (, );
    template<typename InputIterator, typename ValueAllocator> 
       (, , );
  }
}

  
    
      template<typename T> struct list_of;

      typedef boost::container::list< polymorphic_allocator<  ;
    }
  }
}

  
    template<typename Key, typename T, typename Compare, 
             typename Allocator, 
             typename Options> 
      class map;
    template<typename Key, typename T, typename Compare, 
             typename Allocator = new_allocator< , 
             typename Options> 
      class multimap;
    template<typename InputIterator>  (, );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (, , );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (, , , );
    template<typename InputIterator> 
       (ordered_unique_range_t, , );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (ordered_unique_range_t, , , 
           );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (ordered_unique_range_t, , , 
           , );
    template<typename InputIterator>  (, );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (, , );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (, , , 
                );
    template<typename InputIterator> 
       (ordered_range_t, , );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (ordered_range_t, , , 
                );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (ordered_range_t, , , 
                , );
  }
}

  
    
      template<typename Key, typename T, typename Compare, 
               typename Options> 
        struct map_of;
      template<typename Key, typename T, typename Compare, 
               typename Options> 
        struct multimap_of;

      typedef boost::container::map< polymorphic_allocator<  ;
      typedef boost::container::multimap< polymorphic_allocator<  ;
    }
  }
}

  
    template<> class new_allocator<>;

    template<typename T> class new_allocator;
  }
}

  
    template<typename T, 
              NodesPerBlock = > class node_allocator;
  }
}

  
    template<typename NodeAllocator, typename KeyMapped> class node_handle;

    template<typename Iterator, typename NodeType> 
      struct insert_return_type_base;
  }
}

  
    template< TreeType> struct tree_type;
    template< Enabled> struct optimize_size;
    template< Options> struct tree_assoc_options;
    template< Enabled> struct store_hash;
    template< Enabled> struct cache_begin;
    template< Enabled> struct linear_buckets;
    template< Enabled> struct fastmod_buckets;
    template< Options> struct hash_assoc_options;
    struct growth_factor_50;
    struct growth_factor_60;
    struct growth_factor_100;
    template<typename GrowthFactor> struct growth_factor;
    template<typename StoredSizeType> struct stored_size;
    template< Options> struct vector_options;
    template< Alignment> struct inplace_alignment;
    template< Options> struct small_vector_options;
    template< ThrowOnOverflow> struct throw_on_overflow;
    template< Options> struct static_vector_options;
    template< Options> struct devector_options;
    template< Options> struct deque_options;
    template< BlockBytes> struct block_bytes;
    template< BlockSize> struct block_size;

    enum tree_type_enum;
    typedef boost::container::tree_assoc_options<  ;
    typedef boost::container::hash_assoc_options<  ;
    typedef boost::container::vector_options<  ;
    typedef boost::container::small_vector_options<  ;
    typedef boost::container::static_vector_options<  ;
    typedef boost::container::devector_options<  ;
    typedef boost::container::deque_options<  ;
  }
}

  
    
      memory_resource * ();
      memory_resource * ();
      memory_resource * (memory_resource *);
      memory_resource * ();
    }
  }
}

  
    
      class memory_resource;
    }
  }
}

  
    
      class monotonic_buffer_resource;
    }
  }
}

  
    
      template<typename T> class polymorphic_allocator;
      template<typename T1, typename T2> 
         (polymorphic_allocator< , 
                        polymorphic_allocator< );
      template<typename T1, typename T2> 
         (polymorphic_allocator< , 
                        polymorphic_allocator< );
    }
  }
}

  
    
      struct pool_options;
    }
  }
}

  
    
      template<typename Allocator> class resource_adaptor_imp;
      typedef resource_adaptor_imp< allocator_traits<  ;
    }
    
      template<typename T> struct max_allocator_alignment;

      template<typename T> struct max_allocator_alignment<::>;
      template<typename T> struct max_allocator_alignment<>;
    }
  }
}

  
    
      class synchronized_pool_resource;
    }
  }
}

  
    
      class unsynchronized_pool_resource;
    }
  }
}

  
    template<typename OuterAlloc,  InnerAllocs> class scoped_allocator_adaptor;
    template<typename OuterA1, typename OuterA2, 
              > 
       (scoped_allocator_adaptor<  a, 
                      scoped_allocator_adaptor<  b);
    template<typename OuterA1, typename OuterA2, 
              > 
       (scoped_allocator_adaptor<  a, 
                      scoped_allocator_adaptor<  b);
  }
}

This header file forward declares boost::container::scoped_allocator_adaptor


  
    template<typename Key, typename Compare, 
             typename Allocator = new_allocator<, 
             typename Options> 
      class set;
    template<typename Key, typename Compare, 
             typename Allocator = new_allocator<, 
             typename Options> 
      class multiset;
    template<typename InputIterator>  (, );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (, , );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (, , , );
    template<typename InputIterator> 
       (ordered_unique_range_t, , );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (ordered_unique_range_t, , , 
           );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (ordered_unique_range_t, , , 
           , );
    template<typename InputIterator>  (, );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (, , );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (, , , 
                );
    template<typename InputIterator> 
       (ordered_range_t, , );
    template<typename InputIterator, typename AllocatorOrCompare> 
       (ordered_range_t, , , 
                );
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename , 
             typename > 
       (ordered_range_t, , , 
                , );
  }
}

  
    
      template<typename Key, typename Compare, 
               typename Options> struct set_of;
      template<typename Key, typename Compare, 
               typename Options> 
        struct multiset_of;

      typedef boost::container::set< polymorphic_allocator<  ;
      typedef boost::container::multiset< polymorphic_allocator<  ;
    }
  }
}

  
    template<typename T, typename Allocator> class slist;
    template<typename InpIt>  (, );
    template<typename InpIt, typename Allocator> 
       (, , );
  }
}
  template<typename T, typename ValueAllocator> class insert_iterator<, >;
}

  
    
      template<typename T> struct slist_of;

      typedef boost::container::slist< polymorphic_allocator<  ;
    }
  }
}

  
    template<typename T, typename VoidAlloc, typename Options> 
      class small_vector_allocator;

    template<typename T,  N,  Alignment> struct small_vector_storage;

    template<typename T,  Alignment> struct small_vector_storage<, , >;

    template<typename T, typename SecAlloc, typename Options> 
      class small_vector_base;
    template<typename T,  N, typename Allocator, 
             typename Options> 
      class small_vector;
    
      template<typename Options> struct get_small_vector_opt;

      template<> struct get_small_vector_opt<>;

      template<typename Options> struct get_vopt_from_svopt;

      template<> struct get_vopt_from_svopt<>;

      template<typename T, typename SecAlloc, typename Options> 
        struct vector_for_small_vector;
    }
  }
}

  
    
      template<typename T,  N> struct small_vector_of;

      typedef boost::container::small_vector< polymorphic_allocator<  ;
    }
  }
}

  
    template<typename T, typename Allocator> class stable_vector;
    template<typename InputIterator> 
       (, );
    template<typename InputIterator, typename Allocator> 
       (, , );
  }
}

  
    
      template<typename T> struct stable_vector_of;

      typedef boost::container::stable_vector< polymorphic_allocator<  ;
    }
  }
}

  
    template<typename T,  Capacity, typename Options> class static_vector;
    template<typename V,  C1,  C2, typename O1, 
             typename O2> 
       (static_vector< , 
                      static_vector< );
    template<typename V,  C1,  C2, typename O1, 
             typename O2> 
       (static_vector< , 
                      static_vector< );
    template<typename V,  C1,  C2, typename O1, 
             typename O2> 
       (static_vector< , 
                     static_vector< );
    template<typename V,  C1,  C2, typename O1, 
             typename O2> 
       (static_vector< , 
                     static_vector< );
    template<typename V,  C1,  C2, typename O1, 
             typename O2> 
       (static_vector< , 
                      static_vector< );
    template<typename V,  C1,  C2, typename O1, 
             typename O2> 
       (static_vector< , 
                      static_vector< );
    template<typename V,  C1,  C2, typename O1, 
             typename O2> 
       (static_vector< , static_vector< );
  }
}

  
    template<typename CharT, typename Traits, 
             typename Allocator> 
      class basic_string;
    typedef basic_string< new_allocator<  ;
    typedef basic_string< new_allocator<  ;
    template<typename InputIterator> 
       (, );
    template<typename InputIterator, typename Allocator> 
       (, , );
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string<  
      (basic_string<  x, 
                basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string<  
      (basic_string<  x, 
                basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string<  
      (basic_string<  x, 
                basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string<  
      (basic_string<  x, 
                basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string<  
      ( s, basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string<  
      (basic_string<  x,  s);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string<  
      ( c, basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string<  
      (basic_string<  x,  c);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       ( s, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                       s);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       ( x, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       (basic_string<  x, 
                       y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       ( s, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                       s);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       ( x, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       (basic_string<  x, 
                       y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                     basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       ( s, 
                     basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                      s);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       ( x, 
                     basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       (basic_string<  x, 
                      y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                     basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       ( s, 
                     basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                      s);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       ( x, 
                     basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       (basic_string<  x, 
                      y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       ( s, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                       s);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       ( x, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       (basic_string<  x, 
                       y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       ( s, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                       s);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       ( x, 
                      basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator, 
              BasicStringView> 
       (basic_string<  x, 
                       y);
    template<typename CharT, typename Traits, typename Allocator> 
       (basic_string<  x, 
                basic_string<  y);
    template<typename CharT, typename Traits, typename Allocator> 
       
      ( os, 
                 basic_string<  s);
    template<typename CharT, typename Traits, typename Allocator> 
       
      ( is, 
                 basic_string<  s);
    template<typename CharT, typename Traits, typename Allocator> 
       
      ( is, basic_string<  s, 
               delim);
    template<typename CharT, typename Traits, typename Allocator> 
       
      ( is, 
              basic_string<  s);
    template<typename Ch, typename Allocator> 
       (basic_string<  v);
  }
}

  
    
      template<typename CharT, typename Traits> struct basic_string_of;

      typedef boost::container::basic_string< polymorphic_allocator<  ;
      typedef basic_string_of<  ;
      typedef basic_string_of<  ;
    }
  }
}

  
    class exception;
    class bad_alloc;
    class out_of_range;
    class length_error;
    class logic_error;
    class runtime_error;

    typedef bad_alloc ;
    typedef out_of_range ;
    typedef length_error ;
    typedef logic_error ;
    typedef runtime_error ;
     ();
     ();
     ();
     ();
     ();
  }
}

  
    template<typename T> struct constructible_with_allocator_suffix;
    template<typename T> struct constructible_with_allocator_prefix;
    template<typename T, typename Allocator> struct uses_allocator;
  }
}

This header forward declares boost::container::constructible_with_allocator_prefix, boost::container::constructible_with_allocator_suffix and boost::container::uses_allocator. Also defines the following types:


  
    struct erased_type;
    typedef  ;

    static  allocator_arg;
  }
}

  
    template<typename T, typename A, typename Options> class vector;
  }
}

  
    
      template<typename T> struct vector_of;

      typedef boost::container::vector< polymorphic_allocator<  ;
    }
  }
}

PrevUpHomeNext