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/pmr/set.hpp>
Header <boost/container/set.hpp>
Header <boost/container/pmr/slist.hpp>
Header <boost/container/slist.hpp>
Header <boost/container/pmr/small_vector.hpp>
Header <boost/container/small_vector.hpp>
Header <boost/container/pmr/stable_vector.hpp>
Header <boost/container/stable_vector.hpp>
Header <boost/container/static_vector.hpp>
Header <boost/container/pmr/string.hpp>
Header <boost/container/string.hpp>
Header <boost/container/throw_exception.hpp>
Header <boost/container/uses_allocator.hpp>
Header <boost/container/uses_allocator_fwd.hpp>
Header <boost/container/pmr/vector.hpp>
Header <boost/container/vector.hpp>

Header <boost/container/adaptive_pool.hpp>

namespace boost {
  namespace container {
    template<typename T, std::size_t NodesPerBlock = ADP_nodes_per_block, 
             std::size_t MaxFreeBlocks = ADP_max_free_blocks, 
             std::size_t OverheadPercent = ADP_overhead_percent BOOST_CONTAINER_DOCIGN(  BOOST_MOVE_I unsigned Version  )> 
      class adaptive_pool;
    template<typename T, std::size_t NodesPerBlock = ADP_nodes_per_block, 
             std::size_t MaxFreeBlocks = ADP_max_free_blocks, 
             std::size_t OverheadPercent = ADP_overhead_percent, 
             unsigned Version = 2> 
      class private_adaptive_pool;
  }
}

Header <boost/container/allocator.hpp>

namespace boost {
  namespace container {
    template<typename T, unsigned Version = 2, 
             unsigned int AllocationDisableMask = 0> 
      class allocator;
  }
}

Header <boost/container/allocator_traits.hpp>

namespace boost {
  namespace container {
    template<typename Allocator> struct allocator_traits;
  }
}

Header <boost/container/container_fwd.hpp>

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 

namespace boost {
  namespace container {
    struct default_init_t;
    struct ordered_range_t;
    struct ordered_unique_range_t;

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

Header <boost/container/deque.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = void, typename Options = void> 
      class deque;
    template<typename InputIterator>  deque(InputIterator, InputIterator);
    template<typename InputIterator, typename Allocator> 
       deque(InputIterator, InputIterator, Allocator const &);
  }
}

Header <boost/container/pmr/deque.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename T> struct deque_of;

      typedef boost::container::deque< T, polymorphic_allocator< T > > deque;
    }
  }
}

Header <boost/container/devector.hpp>

namespace boost {
  namespace container {
    template<typename T, typename A = void, typename Options = void> 
      class devector;

    struct reserve_only_tag_t;
    struct reserve_uninitialized_t;
    struct review_implementation_t;
  }
}

Header <boost/container/pmr/devector.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename T, typename GrowthPolicy = growth_factor_60> 
        struct devector_of;

      typedef boost::container::devector< T, GrowthPolicy, polymorphic_allocator< T > > devector;
    }
  }
}

Header <boost/container/flat_map.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename T, typename Compare = std::less<Key>, 
             typename AllocatorOrContainer = new_allocator< std::pair< Key, T> > > 
      class flat_map;
    template<typename Key, typename T, typename Compare = std::less<Key>, 
             typename AllocatorOrContainer = new_allocator< std::pair< Key, T> > > 
      class flat_multimap;
    template<typename InputIterator>  flat_map(InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       flat_map(InputIterator, InputIterator, AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       flat_map(InputIterator, InputIterator, Compare const &, 
                Allocator const &);
    template<typename InputIterator> 
       flat_map(ordered_unique_range_t, InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       flat_map(ordered_unique_range_t, InputIterator, InputIterator, 
                AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       flat_map(ordered_unique_range_t, InputIterator, InputIterator, 
                Compare const &, Allocator const &);
    template<typename InputIterator> 
       flat_multimap(InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       flat_multimap(InputIterator, InputIterator, AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       flat_multimap(InputIterator, InputIterator, Compare const &, 
                     Allocator const &);
    template<typename InputIterator> 
       flat_multimap(ordered_range_t, InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       flat_multimap(ordered_range_t, InputIterator, InputIterator, 
                     AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       flat_multimap(ordered_range_t, InputIterator, InputIterator, 
                     Compare const &, Allocator const &);
  }
}

Header <boost/container/pmr/flat_map.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename Key, typename T, typename Compare = std::less<Key> > 
        struct flat_map_of;
      template<typename Key, typename T, typename Compare = std::less<Key> > 
        struct flat_multimap_of;

      typedef boost::container::flat_map< Key, T, Compare, polymorphic_allocator< std::pair< Key, T > > > flat_map;
      typedef boost::container::flat_multimap< Key, T, Compare, polymorphic_allocator< std::pair< Key, T > > > flat_multimap;
    }
  }
}

Header <boost/container/flat_set.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename Compare = std::less<Key>, 
             typename AllocatorOrContainer = new_allocator<Key> > 
      class flat_multiset;
    template<typename Key, typename Compare = std::less<Key>, 
             typename AllocatorOrContainer = new_allocator<Key> > 
      class flat_set;
    template<typename InputIterator>  flat_set(InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       flat_set(InputIterator, InputIterator, AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       flat_set(InputIterator, InputIterator, Compare const &, 
                Allocator const &);
    template<typename InputIterator> 
       flat_set(ordered_unique_range_t, InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       flat_set(ordered_unique_range_t, InputIterator, InputIterator, 
                AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       flat_set(ordered_unique_range_t, InputIterator, InputIterator, 
                Compare const &, Allocator const &);
    template<typename InputIterator> 
       flat_multiset(InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       flat_multiset(InputIterator, InputIterator, AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       flat_multiset(InputIterator, InputIterator, Compare const &, 
                     Allocator const &);
    template<typename InputIterator> 
       flat_multiset(ordered_range_t, InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       flat_multiset(ordered_range_t, InputIterator, InputIterator, 
                     AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       flat_multiset(ordered_range_t, InputIterator, InputIterator, 
                     Compare const &, Allocator const &);
  }
}

Header <boost/container/pmr/flat_set.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename Key, typename Compare = std::less<Key> > 
        struct flat_multiset_of;
      template<typename Key, typename Compare = std::less<Key> > 
        struct flat_set_of;

      typedef boost::container::flat_set< Key, Compare, polymorphic_allocator< Key > > flat_set;
      typedef boost::container::flat_multiset< Key, Compare, polymorphic_allocator< Key > > flat_multiset;
    }
  }
}

Header <boost/container/list.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = void> class list;
    template<typename InputIterator>  list(InputIterator, InputIterator);
    template<typename InputIterator, typename ValueAllocator> 
       list(InputIterator, InputIterator, ValueAllocator const &);
  }
}

Header <boost/container/pmr/list.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename T> struct list_of;

      typedef boost::container::list< T, polymorphic_allocator< T > > list;
    }
  }
}

Header <boost/container/map.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename T, typename Compare = std::less<Key>, 
             typename Allocator = void, 
             typename Options = tree_assoc_defaults> 
      class map;
    template<typename Key, typename T, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator< std::pair< const Key, T> >, 
             typename Options = tree_assoc_defaults> 
      class multimap;
    template<typename InputIterator>  map(InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       map(InputIterator, InputIterator, AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       map(InputIterator, InputIterator, Compare const &, Allocator const &);
    template<typename InputIterator> 
       map(ordered_unique_range_t, InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       map(ordered_unique_range_t, InputIterator, InputIterator, 
           AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       map(ordered_unique_range_t, InputIterator, InputIterator, 
           Compare const &, Allocator const &);
    template<typename InputIterator>  multimap(InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       multimap(InputIterator, InputIterator, AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       multimap(InputIterator, InputIterator, Compare const &, 
                Allocator const &);
    template<typename InputIterator> 
       multimap(ordered_range_t, InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       multimap(ordered_range_t, InputIterator, InputIterator, 
                AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       multimap(ordered_range_t, InputIterator, InputIterator, 
                Compare const &, Allocator const &);
  }
}

Header <boost/container/pmr/map.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename Key, typename T, typename Compare = std::less<Key>, 
               typename Options = void> 
        struct map_of;
      template<typename Key, typename T, typename Compare = std::less<Key>, 
               typename Options = void> 
        struct multimap_of;

      typedef boost::container::map< Key, T, Compare, polymorphic_allocator< std::pair< const Key, T > >, Options > map;
      typedef boost::container::multimap< Key, T, Compare, polymorphic_allocator< std::pair< const Key, T > >, Options > multimap;
    }
  }
}

Header <boost/container/new_allocator.hpp>

namespace boost {
  namespace container {
    template<typename T> class new_allocator;

    template<> class new_allocator<void>;
  }
}

Header <boost/container/node_allocator.hpp>

namespace boost {
  namespace container {
    template<typename T, 
             std::size_t NodesPerBlock = NodeAlloc_nodes_per_block> 
      class node_allocator;
  }
}

Header <boost/container/node_handle.hpp>

namespace boost {
  namespace container {
    template<typename Iterator, typename NodeType> 
      struct insert_return_type_base;

    template<typename NodeAllocator, typename KeyMapped = void> 
      class node_handle;
  }
}

Header <boost/container/options.hpp>

namespace boost {
  namespace container {
    template<std::size_t BlockBytes> struct block_bytes;
    template<std::size_t BlockSize> struct block_size;
    template<bool Enabled> struct cache_begin;
    template<class ... Options> struct deque_options;
    template<class ... Options> struct devector_options;
    template<bool Enabled> struct fastmod_buckets;
    template<typename GrowthFactor> struct growth_factor;
    struct growth_factor_100;
    struct growth_factor_50;
    struct growth_factor_60;
    template<class ... Options> struct hash_assoc_options;
    template<std::size_t Alignment> struct inplace_alignment;
    template<bool Enabled> struct linear_buckets;
    template<bool Enabled> struct optimize_size;
    template<class ... Options> struct small_vector_options;
    template<class ... Options> struct static_vector_options;
    template<bool Enabled> struct store_hash;
    template<typename StoredSizeType> struct stored_size;
    template<bool ThrowOnOverflow> struct throw_on_overflow;
    template<class ... Options> struct tree_assoc_options;
    template<tree_type_enum TreeType> struct tree_type;
    template<class ... Options> struct vector_options;

    enum tree_type_enum;
    typedef typename boost::container::tree_assoc_options< Options... >::type tree_assoc_options_t;
    typedef typename boost::container::hash_assoc_options< Options... >::type hash_assoc_options_t;
    typedef typename boost::container::vector_options< Options... >::type vector_options_t;
    typedef typename boost::container::small_vector_options< Options... >::type small_vector_options_t;
    typedef typename boost::container::static_vector_options< Options... >::type static_vector_options_t;
    typedef typename boost::container::devector_options< Options... >::type devector_options_t;
    typedef typename boost::container::deque_options< Options... >::type deque_options_t;
  }
}

Header <boost/container/pmr/global_resource.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      memory_resource * new_delete_resource();
      memory_resource * null_memory_resource();
      memory_resource * set_default_resource(memory_resource *);
      memory_resource * get_default_resource();
    }
  }
}

Header <boost/container/pmr/memory_resource.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      class memory_resource;
    }
  }
}

Header <boost/container/pmr/monotonic_buffer_resource.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      class monotonic_buffer_resource;
    }
  }
}

Header <boost/container/pmr/polymorphic_allocator.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename T> class polymorphic_allocator;
      template<typename T1, typename T2> 
        bool operator==(const polymorphic_allocator< T1 > &, 
                        const polymorphic_allocator< T2 > &);
      template<typename T1, typename T2> 
        bool operator!=(const polymorphic_allocator< T1 > &, 
                        const polymorphic_allocator< T2 > &);
    }
  }
}

Header <boost/container/pmr/pool_options.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      struct pool_options;
    }
  }
}

Header <boost/container/pmr/resource_adaptor.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename Allocator> class resource_adaptor_imp;
      typedef resource_adaptor_imp< typename allocator_traits< Allocator >::template rebind_alloc< char > > resource_adaptor;
    }
    namespace pmr_dtl {
      template<typename T> struct max_allocator_alignment;

      template<typename T> 
        struct max_allocator_alignment<::boost::container::new_allocator< T >>;
      template<typename T> struct max_allocator_alignment<std::allocator< T >>;
    }
  }
}

Header <boost/container/pmr/synchronized_pool_resource.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      class synchronized_pool_resource;
    }
  }
}

Header <boost/container/pmr/unsynchronized_pool_resource.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      class unsynchronized_pool_resource;
    }
  }
}

Header <boost/container/scoped_allocator.hpp>

namespace boost {
  namespace container {
    template<typename OuterAlloc, typename ... InnerAllocs> 
      class scoped_allocator_adaptor;
    template<typename OuterA1, typename OuterA2, 
             BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS > 
      bool operator==(const scoped_allocator_adaptor< OuterA1, InnerAllocs... > & a, 
                      const scoped_allocator_adaptor< OuterA2, InnerAllocs... > & b);
    template<typename OuterA1, typename OuterA2, 
             BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS > 
      bool operator!=(const scoped_allocator_adaptor< OuterA1, InnerAllocs... > & a, 
                      const scoped_allocator_adaptor< OuterA2, InnerAllocs... > & b);
  }
}

Header <boost/container/scoped_allocator_fwd.hpp>

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

Header <boost/container/pmr/set.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename Key, typename Compare = std::less<Key>, 
               typename Options = void> 
        struct multiset_of;
      template<typename Key, typename Compare = std::less<Key>, 
               typename Options = void> 
        struct set_of;

      typedef boost::container::set< Key, Compare, polymorphic_allocator< Key >, Options > set;
      typedef boost::container::multiset< Key, Compare, polymorphic_allocator< Key >, Options > multiset;
    }
  }
}

Header <boost/container/set.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator<Key>, 
             typename Options = tree_assoc_defaults> 
      class multiset;
    template<typename Key, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator<Key>, 
             typename Options = void> 
      class set;
    template<typename InputIterator>  set(InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       set(InputIterator, InputIterator, AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       set(InputIterator, InputIterator, Compare const &, Allocator const &);
    template<typename InputIterator> 
       set(ordered_unique_range_t, InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       set(ordered_unique_range_t, InputIterator, InputIterator, 
           AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       set(ordered_unique_range_t, InputIterator, InputIterator, 
           Compare const &, Allocator const &);
    template<typename InputIterator>  multiset(InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       multiset(InputIterator, InputIterator, AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       multiset(InputIterator, InputIterator, Compare const &, 
                Allocator const &);
    template<typename InputIterator> 
       multiset(ordered_range_t, InputIterator, InputIterator);
    template<typename InputIterator, typename AllocatorOrCompare> 
       multiset(ordered_range_t, InputIterator, InputIterator, 
                AllocatorOrCompare const &);
    template<typename InputIterator, typename Compare, typename Allocator, 
             typename  = dtl::require_nonallocator_t<Compare>, 
             typename  = dtl::require_allocator_t<Allocator> > 
       multiset(ordered_range_t, InputIterator, InputIterator, 
                Compare const &, Allocator const &);
  }
}

Header <boost/container/pmr/slist.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename T> struct slist_of;

      typedef boost::container::slist< T, polymorphic_allocator< T > > slist;
    }
  }
}

Header <boost/container/slist.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = void> class slist;
    template<typename InpIt>  slist(InpIt, InpIt);
    template<typename InpIt, typename Allocator> 
       slist(InpIt, InpIt, Allocator const &);
  }
}namespace std {
  template<typename T, typename ValueAllocator> 
    class insert_iterator<boost::container::slist< T, ValueAllocator >>;
}

Header <boost/container/pmr/small_vector.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename T, std::size_t N> struct small_vector_of;

      typedef boost::container::small_vector< T, N, polymorphic_allocator< T > > small_vector;
    }
  }
}

Header <boost/container/small_vector.hpp>

namespace boost {
  namespace container {
    template<typename T, std::size_t N, typename Allocator = void, 
             typename Options = void> 
      class small_vector;
    template<typename T, typename VoidAlloc = void, typename Options = void> 
      class small_vector_allocator;
    template<typename T, typename SecAlloc, typename Options> 
      class small_vector_base;

    template<typename T, std::size_t N, std::size_t Alignment> 
      struct small_vector_storage;

    template<typename T, std::size_t Alignment> 
      struct small_vector_storage<T, 0u, Alignment>;
    namespace dtl {
      template<typename Options> struct get_small_vector_opt;

      template<> struct get_small_vector_opt<void>;

      template<typename Options> struct get_vopt_from_svopt;

      template<> struct get_vopt_from_svopt<void>;

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

Header <boost/container/pmr/stable_vector.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename T> struct stable_vector_of;

      typedef boost::container::stable_vector< T, polymorphic_allocator< T > > stable_vector;
    }
  }
}

Header <boost/container/stable_vector.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = void> class stable_vector;
    template<typename InputIterator> 
       stable_vector(InputIterator, InputIterator);
    template<typename InputIterator, typename Allocator> 
       stable_vector(InputIterator, InputIterator, Allocator const &);
  }
}

Header <boost/container/static_vector.hpp>

namespace boost {
  namespace container {
    template<typename T, std::size_t Capacity, typename Options = void> 
      class static_vector;
    template<typename V, std::size_t C1, std::size_t C2, typename O1, 
             typename O2> 
      bool operator==(static_vector< V, C1, O1 > const &, 
                      static_vector< V, C2, O2 > const &);
    template<typename V, std::size_t C1, std::size_t C2, typename O1, 
             typename O2> 
      bool operator!=(static_vector< V, C1, O1 > const &, 
                      static_vector< V, C2, O2 > const &);
    template<typename V, std::size_t C1, std::size_t C2, typename O1, 
             typename O2> 
      bool operator<(static_vector< V, C1, O1 > const &, 
                     static_vector< V, C2, O2 > const &);
    template<typename V, std::size_t C1, std::size_t C2, typename O1, 
             typename O2> 
      bool operator>(static_vector< V, C1, O1 > const &, 
                     static_vector< V, C2, O2 > const &);
    template<typename V, std::size_t C1, std::size_t C2, typename O1, 
             typename O2> 
      bool operator<=(static_vector< V, C1, O1 > const &, 
                      static_vector< V, C2, O2 > const &);
    template<typename V, std::size_t C1, std::size_t C2, typename O1, 
             typename O2> 
      bool operator>=(static_vector< V, C1, O1 > const &, 
                      static_vector< V, C2, O2 > const &);
    template<typename V, std::size_t C1, std::size_t C2, typename O1, 
             typename O2> 
      void swap(static_vector< V, C1, O1 > &, static_vector< V, C2, O2 > &);
  }
}

Header <boost/container/pmr/string.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename CharT, typename Traits = std::char_traits<CharT> > 
        struct basic_string_of;

      typedef boost::container::basic_string< CharT, Traits, polymorphic_allocator< CharT > > basic_string;
      typedef basic_string_of< char >::type string;
      typedef basic_string_of< wchar_t >::type wstring;
    }
  }
}

Header <boost/container/string.hpp>

namespace boost {
  namespace container {
    template<typename CharT, typename Traits = std::char_traits<CharT>, 
             typename Allocator = void> 
      class basic_string;
    typedef basic_string< char,std::char_traits< char >,new_allocator< char > > string;
    typedef basic_string< wchar_t,std::char_traits< wchar_t >,new_allocator< wchar_t > > wstring;
    template<typename InputIterator> 
       basic_string(InputIterator, InputIterator);
    template<typename InputIterator, typename Allocator> 
       basic_string(InputIterator, InputIterator, Allocator const &);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(const basic_string< CharT, Traits, Allocator > & x, 
                const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(basic_string< CharT, Traits, Allocator > && x, 
                basic_string< CharT, Traits, Allocator > && y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(basic_string< CharT, Traits, Allocator > && x, 
                const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(const basic_string< CharT, Traits, Allocator > & x, 
                basic_string< CharT, Traits, Allocator > && y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(const CharT * s, basic_string< CharT, Traits, Allocator > y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(basic_string< CharT, Traits, Allocator > x, const CharT * s);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(CharT c, basic_string< CharT, Traits, Allocator > y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(basic_string< CharT, Traits, Allocator > x, const CharT c);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator==(const basic_string< CharT, Traits, Allocator > & x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator==(const CharT * s, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator==(const basic_string< CharT, Traits, Allocator > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator==(BasicStringView< CharT, Traits > x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator==(const basic_string< CharT, Traits, Allocator > & x, 
                      BasicStringView< CharT, Traits > y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator!=(const basic_string< CharT, Traits, Allocator > & x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator!=(const CharT * s, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator!=(const basic_string< CharT, Traits, Allocator > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator!=(BasicStringView< CharT, Traits > x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator!=(const basic_string< CharT, Traits, Allocator > & x, 
                      BasicStringView< CharT, Traits > y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<(const basic_string< CharT, Traits, Allocator > & x, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<(const CharT * s, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<(const basic_string< CharT, Traits, Allocator > & x, 
                     const CharT * s);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator<(BasicStringView< CharT, Traits > x, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator<(const basic_string< CharT, Traits, Allocator > & x, 
                     BasicStringView< CharT, Traits > y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>(const basic_string< CharT, Traits, Allocator > & x, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>(const CharT * s, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>(const basic_string< CharT, Traits, Allocator > & x, 
                     const CharT * s);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator>(BasicStringView< CharT, Traits > x, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator>(const basic_string< CharT, Traits, Allocator > & x, 
                     BasicStringView< CharT, Traits > y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<=(const basic_string< CharT, Traits, Allocator > & x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<=(const CharT * s, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<=(const basic_string< CharT, Traits, Allocator > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator<=(BasicStringView< CharT, Traits > x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator<=(const basic_string< CharT, Traits, Allocator > & x, 
                      BasicStringView< CharT, Traits > y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>=(const basic_string< CharT, Traits, Allocator > & x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>=(const CharT * s, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>=(const basic_string< CharT, Traits, Allocator > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator>=(BasicStringView< CharT, Traits > x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator, 
             template< class, class > class BasicStringView> 
      bool operator>=(const basic_string< CharT, Traits, Allocator > & x, 
                      BasicStringView< CharT, Traits > y);
    template<typename CharT, typename Traits, typename Allocator> 
      void swap(basic_string< CharT, Traits, Allocator > & x, 
                basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      std::basic_ostream< CharT, Traits > & 
      operator<<(std::basic_ostream< CharT, Traits > & os, 
                 const basic_string< CharT, Traits, Allocator > & s);
    template<typename CharT, typename Traits, typename Allocator> 
      std::basic_istream< CharT, Traits > & 
      operator>>(std::basic_istream< CharT, Traits > & is, 
                 basic_string< CharT, Traits, Allocator > & s);
    template<typename CharT, typename Traits, typename Allocator> 
      std::basic_istream< CharT, Traits > & 
      getline(std::istream & is, basic_string< CharT, Traits, Allocator > & s, 
              CharT delim);
    template<typename CharT, typename Traits, typename Allocator> 
      std::basic_istream< CharT, Traits > & 
      getline(std::basic_istream< CharT, Traits > & is, 
              basic_string< CharT, Traits, Allocator > & s);
    template<typename Ch, typename Allocator> 
      std::size_t hash_value(basic_string< Ch, std::char_traits< Ch >, Allocator > const & v);
  }
}

Header <boost/container/throw_exception.hpp>

namespace boost {
  namespace container {
    class bad_alloc;
    class exception;
    class length_error;
    class logic_error;
    class out_of_range;
    class runtime_error;

    typedef bad_alloc bad_alloc_t;
    typedef out_of_range out_of_range_t;
    typedef length_error length_error_t;
    typedef logic_error logic_error_t;
    typedef runtime_error runtime_error_t;
    void throw_bad_alloc();
    void throw_out_of_range(const char *);
    void throw_length_error(const char *);
    void throw_logic_error(const char *);
    void throw_runtime_error(const char *);
  }
}

Header <boost/container/uses_allocator.hpp>

namespace boost {
  namespace container {
    template<typename T> struct constructible_with_allocator_prefix;
    template<typename T> struct constructible_with_allocator_suffix;
    template<typename T, typename Allocator> struct uses_allocator;
  }
}

Header <boost/container/uses_allocator_fwd.hpp>

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: 

namespace boost {
  namespace container {
    struct erased_type;
    typedef unspecified allocator_arg_t;

    static allocator_arg_t allocator_arg;
  }
}

Header <boost/container/pmr/vector.hpp>

namespace boost {
  namespace container {
    namespace pmr {
      template<typename T> struct vector_of;

      typedef boost::container::vector< T, polymorphic_allocator< T > > vector;
    }
  }
}

Header <boost/container/vector.hpp>

namespace boost {
  namespace container {
    template<typename T, typename A = void, typename Options = void> 
      class vector;
    template<typename InputIterator>  vector(InputIterator, InputIterator);
    template<typename InputIterator, typename Allocator> 
       vector(InputIterator, InputIterator, Allocator const &);
  }
}
Copyright © 2009-2018 Ion Gaztanaga

Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

PrevUpHomeNext