+
+
namespace boost { + namespace container { + template<typename T, std::size_t NodesPerBlock BOOST_CONTAINER_DOCONLY, + std::size_t MaxFreeBlocks BOOST_CONTAINER_DOCONLY, + std::size_t OverheadPercent BOOST_CONTAINER_DOCONLY> + class adaptive_pool; + } +}+
This class is an extended STL-compatible that offers advanced allocation mechanism (in-place expansion, shrinking, burst-allocation...)
+This allocator is a wrapper around a modified DLmalloc.
+namespace boost { + namespace container { + template<typename T> class allocator; + } +}+
-template<typename Alloc> struct allocator_traits;+
namespace boost { + namespace container { + template<typename Alloc> struct allocator_traits; + } +}
This header file forward declares the following containers:
+boost::container::string
boost::container::wstring
+
+It forward declares the following allocators:
+ ++
+And finally it defines the following types
namespace boost { namespace container { struct ordered_range_t; struct ordered_unique_range_t; + struct default_init_t; + + enum tree_type_enum; + typedef implementation_defined tree_assoc_defaults; static const ordered_range_t ordered_range; static const ordered_unique_range_t ordered_unique_range; + static const default_init_t default_init; } }
namespace boost { namespace container { - template<typename T, typename A = std::allocator<T> > class deque; - template<typename T, typename A> - bool operator==(const deque< T, A > & x, const deque< T, A > & y); - template<typename T, typename A> - bool operator<(const deque< T, A > & x, const deque< T, A > & y); - template<typename T, typename A> - bool operator!=(const deque< T, A > & x, const deque< T, A > & y); - template<typename T, typename A> - bool operator>(const deque< T, A > & x, const deque< T, A > & y); - template<typename T, typename A> - bool operator<=(const deque< T, A > & x, const deque< T, A > & y); - template<typename T, typename A> - bool operator>=(const deque< T, A > & x, const deque< T, A > & y); - template<typename T, typename A> - void swap(deque< T, A > & x, deque< T, A > & y); + template<typename T, typename Allocator = std::allocator<T> > class deque; } }@@ -88,56 +141,12 @@ Header <boost/container/flat_map.hpp>
namespace boost { namespace container { - template<typename Key, typename T, - typename Pred = std::less< std::pair< Key, T> >, - typename A = std::allocator<T> > + template<typename Key, typename T, typename Compare = std::less<Key>, + typename Allocator = std::allocator< std::pair< Key, T> > > class flat_map; - template<typename Key, typename T, - typename Pred = std::less< std::pair< Key, T> >, - typename A = std::allocator<T> > + template<typename Key, typename T, typename Compare = std::less<Key>, + typename Allocator = std::allocator< std::pair< Key, T> > > class flat_multimap; - template<typename Key, typename T, typename Pred, typename A> - bool operator==(const flat_map< Key, T, Pred, A > & x, - const flat_map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator<(const flat_map< Key, T, Pred, A > & x, - const flat_map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator!=(const flat_map< Key, T, Pred, A > & x, - const flat_map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator>(const flat_map< Key, T, Pred, A > & x, - const flat_map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator<=(const flat_map< Key, T, Pred, A > & x, - const flat_map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator>=(const flat_map< Key, T, Pred, A > & x, - const flat_map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - void swap(flat_map< Key, T, Pred, A > & x, - flat_map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator==(const flat_multimap< Key, T, Pred, A > & x, - const flat_multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator<(const flat_multimap< Key, T, Pred, A > & x, - const flat_multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator!=(const flat_multimap< Key, T, Pred, A > & x, - const flat_multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator>(const flat_multimap< Key, T, Pred, A > & x, - const flat_multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator<=(const flat_multimap< Key, T, Pred, A > & x, - const flat_multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator>=(const flat_multimap< Key, T, Pred, A > & x, - const flat_multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - void swap(flat_multimap< Key, T, Pred, A > & x, - flat_multimap< Key, T, Pred, A > & y); } }@@ -146,53 +155,12 @@ Header <boost/container/flat_set.hpp>
namespace boost { namespace container { - template<typename T, typename Pred = std::less<T>, - typename A = std::allocator<T> > + template<typename Key, typename Compare = std::less<Key>, + typename Allocator = std::allocator<Key> > class flat_set; - template<typename T, typename Pred = std::less<T>, - typename A = std::allocator<T> > + template<typename Key, typename Compare = std::less<Key>, + typename Allocator = std::allocator<Key> > class flat_multiset; - template<typename T, typename Pred, typename A> - bool operator==(const flat_set< T, Pred, A > & x, - const flat_set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator<(const flat_set< T, Pred, A > & x, - const flat_set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator!=(const flat_set< T, Pred, A > & x, - const flat_set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator>(const flat_set< T, Pred, A > & x, - const flat_set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator<=(const flat_set< T, Pred, A > & x, - const flat_set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator>=(const flat_set< T, Pred, A > & x, - const flat_set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - void swap(flat_set< T, Pred, A > & x, flat_set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator==(const flat_multiset< T, Pred, A > & x, - const flat_multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator<(const flat_multiset< T, Pred, A > & x, - const flat_multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator!=(const flat_multiset< T, Pred, A > & x, - const flat_multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator>(const flat_multiset< T, Pred, A > & x, - const flat_multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator<=(const flat_multiset< T, Pred, A > & x, - const flat_multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator>=(const flat_multiset< T, Pred, A > & x, - const flat_multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - void swap(flat_multiset< T, Pred, A > & x, - flat_multiset< T, Pred, A > & y); } }@@ -201,21 +169,7 @@ Header <boost/container/list.hpp>
namespace boost { namespace container { - template<typename T, typename A = std::allocator<T> > class list; - template<typename T, typename A> - bool operator==(const list< T, A > & x, const list< T, A > & y); - template<typename T, typename A> - bool operator<(const list< T, A > & x, const list< T, A > & y); - template<typename T, typename A> - bool operator!=(const list< T, A > & x, const list< T, A > & y); - template<typename T, typename A> - bool operator>(const list< T, A > & x, const list< T, A > & y); - template<typename T, typename A> - bool operator<=(const list< T, A > & x, const list< T, A > & y); - template<typename T, typename A> - bool operator>=(const list< T, A > & x, const list< T, A > & y); - template<typename T, typename A> - void swap(list< T, A > & x, list< T, A > & y); + template<typename T, typename Allocator = std::allocator<T> > class list; } }@@ -224,55 +178,36 @@ Header <boost/container/map.hpp>
namespace boost { namespace container { - template<typename Key, typename T, - typename Pred = std::less< std::pair< const Key, T> >, - typename A = std::allocator<T> > + template<typename Key, typename T, typename Compare = std::less<Key>, + typename Allocator = std::allocator< std::pair< const Key, T> >, + typename MapOptions = tree_assoc_defaults> class map; - template<typename Key, typename T, - typename Pred = std::less< std::pair< const Key, T> >, - typename A = std::allocator<T> > + template<typename Key, typename T, typename Compare = std::less<Key>, + typename Allocator = std::allocator< std::pair< const Key, T> >, + typename MultiMapOptions = tree_assoc_defaults> class multimap; - template<typename Key, typename T, typename Pred, typename A> - bool operator==(const map< Key, T, Pred, A > & x, - const map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator<(const map< Key, T, Pred, A > & x, - const map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator!=(const map< Key, T, Pred, A > & x, - const map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator>(const map< Key, T, Pred, A > & x, - const map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator<=(const map< Key, T, Pred, A > & x, - const map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator>=(const map< Key, T, Pred, A > & x, - const map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - void swap(map< Key, T, Pred, A > & x, map< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator==(const multimap< Key, T, Pred, A > & x, - const multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator<(const multimap< Key, T, Pred, A > & x, - const multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator!=(const multimap< Key, T, Pred, A > & x, - const multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator>(const multimap< Key, T, Pred, A > & x, - const multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator<=(const multimap< Key, T, Pred, A > & x, - const multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - bool operator>=(const multimap< Key, T, Pred, A > & x, - const multimap< Key, T, Pred, A > & y); - template<typename Key, typename T, typename Pred, typename A> - void swap(multimap< Key, T, Pred, A > & x, - multimap< Key, T, Pred, A > & y); + } +}+ +
namespace boost { + namespace container { + template<typename T, + std::size_t NodesPerBlock = NodeAlloc_nodes_per_block> + class node_allocator; + } +}+
namespace boost { + namespace container { + template<tree_type_enum TreeType> struct tree_type; + template<bool Enabled> struct optimize_size; + template<class... Options> struct tree_assoc_options; } }
namespace boost { namespace container { - template<typename T> struct constructible_with_allocator_suffix; - template<typename T> struct constructible_with_allocator_prefix; + template<typename T> struct constructible_with_allocator_suffix; + template<typename T> struct constructible_with_allocator_prefix; template<typename T, typename Alloc> struct uses_allocator; template<typename OuterAlloc, typename... InnerAllocs> class scoped_allocator_adaptor; template<typename OuterA1, typename OuterA2, typename... InnerAllocs> - bool operator==(const scoped_allocator_adaptor< OuterA1, InnerAllocs... > & a, + bool operator==(const scoped_allocator_adaptor< OuterA1, InnerAllocs... > & a, const scoped_allocator_adaptor< OuterA2, InnerAllocs... > & b); template<typename OuterA1, typename OuterA2, typename... InnerAllocs> - bool operator!=(const scoped_allocator_adaptor< OuterA1, InnerAllocs... > & a, + bool operator!=(const scoped_allocator_adaptor< OuterA1, InnerAllocs... > & a, const scoped_allocator_adaptor< OuterA2, InnerAllocs... > & b); } }@@ -299,6 +234,7 @@
This header file forward declares boost::container::scoped_allocator_adaptor and defines the following types:
namespace boost { namespace container { struct allocator_arg_t; @@ -312,50 +248,14 @@ Header <boost/container/set.hpp>
namespace boost { namespace container { - template<typename T, typename Pred = std::less<T>, - typename A = std::allocator<T> > + template<typename Key, typename Compare = std::less<Key>, + typename Allocator = std::allocator<Key>, + typename SetOptions = tree_assoc_defaults> class set; - template<typename T, typename Pred = std::less<T>, - typename A = std::allocator<T> > + template<typename Key, typename Compare = std::less<Key>, + typename Allocator = std::allocator<Key>, + typename MultiSetOptions = tree_assoc_defaults> class multiset; - template<typename T, typename Pred, typename A> - bool operator==(const set< T, Pred, A > & x, - const set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator<(const set< T, Pred, A > & x, const set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator!=(const set< T, Pred, A > & x, - const set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator>(const set< T, Pred, A > & x, const set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator<=(const set< T, Pred, A > & x, - const set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator>=(const set< T, Pred, A > & x, - const set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - void swap(set< T, Pred, A > & x, set< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator==(const multiset< T, Pred, A > & x, - const multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator<(const multiset< T, Pred, A > & x, - const multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator!=(const multiset< T, Pred, A > & x, - const multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator>(const multiset< T, Pred, A > & x, - const multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator<=(const multiset< T, Pred, A > & x, - const multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - bool operator>=(const multiset< T, Pred, A > & x, - const multiset< T, Pred, A > & y); - template<typename T, typename Pred, typename A> - void swap(multiset< T, Pred, A > & x, multiset< T, Pred, A > & y); } }@@ -364,21 +264,7 @@ Header <boost/container/slist.hpp>
namespace boost { namespace container { - template<typename T, typename A = std::allocator<T> > class slist; - template<typename T, typename A> - bool operator==(const slist< T, A > & x, const slist< T, A > & y); - template<typename T, typename A> - bool operator<(const slist< T, A > & sL1, const slist< T, A > & sL2); - template<typename T, typename A> - bool operator!=(const slist< T, A > & sL1, const slist< T, A > & sL2); - template<typename T, typename A> - bool operator>(const slist< T, A > & sL1, const slist< T, A > & sL2); - template<typename T, typename A> - bool operator<=(const slist< T, A > & sL1, const slist< T, A > & sL2); - template<typename T, typename A> - bool operator>=(const slist< T, A > & sL1, const slist< T, A > & sL2); - template<typename T, typename A> - void swap(slist< T, A > & x, slist< T, A > & y); + template<typename T, typename Allocator = std::allocator<T> > class slist; } }@@ -387,27 +273,37 @@ Header <boost/container/stable_vector.hpp>
namespace boost { namespace container { - template<typename T, typename A = std::allocator<T> > class stable_vector; - template<typename T, typename A> - bool operator==(const stable_vector< T, A > & x, - const stable_vector< T, A > & y); - template<typename T, typename A> - bool operator<(const stable_vector< T, A > & x, - const stable_vector< T, A > & y); - template<typename T, typename A> - bool operator!=(const stable_vector< T, A > & x, - const stable_vector< T, A > & y); - template<typename T, typename A> - bool operator>(const stable_vector< T, A > & x, - const stable_vector< T, A > & y); - template<typename T, typename A> - bool operator>=(const stable_vector< T, A > & x, - const stable_vector< T, A > & y); - template<typename T, typename A> - bool operator<=(const stable_vector< T, A > & x, - const stable_vector< T, A > & y); - template<typename T, typename A> - void swap(stable_vector< T, A > & x, stable_vector< T, A > & y); + template<typename T, typename Allocator = std::allocator<T> > + class stable_vector; + } +}+ +
namespace boost { + namespace container { + template<typename Value, std::size_t Capacity> class static_vector; + template<typename V, std::size_t C1, std::size_t C2> + bool operator==(static_vector< V, C1 > const &, + static_vector< V, C2 > const &); + template<typename V, std::size_t C1, std::size_t C2> + bool operator!=(static_vector< V, C1 > const &, + static_vector< V, C2 > const &); + template<typename V, std::size_t C1, std::size_t C2> + bool operator<(static_vector< V, C1 > const &, + static_vector< V, C2 > const &); + template<typename V, std::size_t C1, std::size_t C2> + bool operator>(static_vector< V, C1 > const &, + static_vector< V, C2 > const &); + template<typename V, std::size_t C1, std::size_t C2> + bool operator<=(static_vector< V, C1 > const &, + static_vector< V, C2 > const &); + template<typename V, std::size_t C1, std::size_t C2> + bool operator>=(static_vector< V, C1 > const &, + static_vector< V, C2 > const &); + template<typename V, std::size_t C1, std::size_t C2> + void swap(static_vector< V, C1 > &, static_vector< V, C2 > &); } }
namespace boost { namespace container { template<typename CharT, typename Traits = std::char_traits<CharT>, - typename A = std::allocator<CharT> > + typename Allocator = std::allocator<CharT> > class basic_string; typedef basic_string< char,std::char_traits< char >,std::allocator< char > > string; typedef basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > wstring; - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > - operator+(const basic_string< CharT, Traits, A > & x, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && - operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx, - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && - operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && - operator+(const basic_string< CharT, Traits, A > & x, - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > - operator+(const CharT * s, const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && - operator+(const CharT * s, - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > - operator+(CharT c, const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && - operator+(CharT c, - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > - operator+(const basic_string< CharT, Traits, A > & x, const CharT * s); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && - operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx, - const CharT * s); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > - operator+(const basic_string< CharT, Traits, A > & x, const CharT c); - template<typename CharT, typename Traits, typename A> - basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && - operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx, - const CharT c); - template<typename CharT, typename Traits, typename A> - bool operator==(const basic_string< CharT, Traits, A > & x, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator==(const CharT * s, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator==(const basic_string< CharT, Traits, A > & x, + 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 > && mx, + basic_string< CharT, Traits, Allocator > && my); + template<typename CharT, typename Traits, typename Allocator> + basic_string< CharT, Traits, Allocator > + operator+(basic_string< CharT, Traits, Allocator > && mx, + 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 > && my); + 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 A> - bool operator!=(const basic_string< CharT, Traits, A > & x, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator!=(const CharT * s, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator!=(const basic_string< CharT, Traits, A > & x, + 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 A> - bool operator<(const basic_string< CharT, Traits, A > & x, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator<(const CharT * s, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator<(const basic_string< CharT, Traits, A > & x, + 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 A> - bool operator>(const basic_string< CharT, Traits, A > & x, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator>(const CharT * s, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator>(const basic_string< CharT, Traits, A > & x, + 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 A> - bool operator<=(const basic_string< CharT, Traits, A > & x, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator<=(const CharT * s, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator<=(const basic_string< CharT, Traits, A > & x, + 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 A> - bool operator>=(const basic_string< CharT, Traits, A > & x, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator>=(const CharT * s, - const basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> - bool operator>=(const basic_string< CharT, Traits, A > & x, + 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 A> - void swap(basic_string< CharT, Traits, A > & x, - basic_string< CharT, Traits, A > & y); - template<typename CharT, typename Traits, typename A> + 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, A > & s); - template<typename CharT, typename Traits, typename A> + 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, A > & s); - template<typename CharT, typename Traits, typename A> + 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, A > & s, + getline(std::istream & is, basic_string< CharT, Traits, Allocator > & s, CharT delim); - template<typename CharT, typename Traits, typename A> + template<typename CharT, typename Traits, typename Allocator> std::basic_istream< CharT, Traits > & - getline(std::basic_istream< CharT, Traits > & is, - basic_string< CharT, Traits, A > & s); - template<typename Ch, typename A> - std::size_t hash_value(basic_string< Ch, std::char_traits< Ch >, A > const & v); + 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); + } +}+ +
namespace boost { + namespace container { + 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 *); } }
namespace boost { namespace container { - template<typename T, typename A = std::allocator<T> > class vector; - template<typename T, typename A> - bool operator==(const vector< T, A > & x, const vector< T, A > & y); - template<typename T, typename A> - bool operator!=(const vector< T, A > & x, const vector< T, A > & y); - template<typename T, typename A> - bool operator<(const vector< T, A > & x, const vector< T, A > & y); - template<typename T, typename A> - void swap(vector< T, A > & x, vector< T, A > & y); + template<typename T, class Allocator BOOST_CONTAINER_DOCONLY> class vector; } }
| - |
+