...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
template<typename Alloc> struct allocator_traits;
namespace boost { namespace container { template<typename T, typename Allocator = std::allocator<T> > class vector; template<typename T, typename Allocator = std::allocator<T> > class stable_vector; template<typename T, typename Allocator = std::allocator<T> > class deque; template<typename T, typename Allocator = std::allocator<T> > class list; template<typename T, typename Allocator = std::allocator<T> > class slist; template<typename Key, typename Compare = std::less<Key>, typename Allocator = std::allocator<Key> > class set; template<typename Key, typename Compare = std::less<Key>, typename Allocator = std::allocator<Key> > class multiset; template<typename Key, typename T, typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T> > > class map; template<typename Key, typename T, typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T> > > class multimap; template<typename Key, typename Compare = std::less<Key>, typename Allocator = std::allocator<Key> > class flat_set; template<typename Key, typename Compare = std::less<Key>, typename Allocator = std::allocator<Key> > class flat_multiset; 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 Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<Key, T> > > class flat_multimap; template<typename CharT, typename Traits = std::char_traits<CharT>, typename Allocator = std::allocator<CharT> > class basic_string; 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; } }
namespace boost { namespace container { template<typename T, typename Allocator> bool operator==(const deque< T, Allocator > & x, const deque< T, Allocator > & y); template<typename T, typename Allocator> bool operator<(const deque< T, Allocator > & x, const deque< T, Allocator > & y); template<typename T, typename Allocator> bool operator!=(const deque< T, Allocator > & x, const deque< T, Allocator > & y); template<typename T, typename Allocator> bool operator>(const deque< T, Allocator > & x, const deque< T, Allocator > & y); template<typename T, typename Allocator> bool operator>=(const deque< T, Allocator > & x, const deque< T, Allocator > & y); template<typename T, typename Allocator> bool operator<=(const deque< T, Allocator > & x, const deque< T, Allocator > & y); template<typename T, typename Allocator> void swap(deque< T, Allocator > & x, deque< T, Allocator > & y); } }
namespace boost { namespace container { template<typename Key, typename T, typename Compare, typename Allocator> bool operator==(const flat_map< Key, T, Compare, Allocator > & x, const flat_map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator<(const flat_map< Key, T, Compare, Allocator > & x, const flat_map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator!=(const flat_map< Key, T, Compare, Allocator > & x, const flat_map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator>(const flat_map< Key, T, Compare, Allocator > & x, const flat_map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator<=(const flat_map< Key, T, Compare, Allocator > & x, const flat_map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator>=(const flat_map< Key, T, Compare, Allocator > & x, const flat_map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> void swap(flat_map< Key, T, Compare, Allocator > & x, flat_map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator==(const flat_multimap< Key, T, Compare, Allocator > & x, const flat_multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator<(const flat_multimap< Key, T, Compare, Allocator > & x, const flat_multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator!=(const flat_multimap< Key, T, Compare, Allocator > & x, const flat_multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator>(const flat_multimap< Key, T, Compare, Allocator > & x, const flat_multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator<=(const flat_multimap< Key, T, Compare, Allocator > & x, const flat_multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator>=(const flat_multimap< Key, T, Compare, Allocator > & x, const flat_multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> void swap(flat_multimap< Key, T, Compare, Allocator > & x, flat_multimap< Key, T, Compare, Allocator > & y); } }
namespace boost { namespace container { template<typename Key, typename Compare, typename Allocator> bool operator==(const flat_set< Key, Compare, Allocator > & x, const flat_set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator<(const flat_set< Key, Compare, Allocator > & x, const flat_set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator!=(const flat_set< Key, Compare, Allocator > & x, const flat_set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator>(const flat_set< Key, Compare, Allocator > & x, const flat_set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator<=(const flat_set< Key, Compare, Allocator > & x, const flat_set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator>=(const flat_set< Key, Compare, Allocator > & x, const flat_set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> void swap(flat_set< Key, Compare, Allocator > & x, flat_set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator==(const flat_multiset< Key, Compare, Allocator > & x, const flat_multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator<(const flat_multiset< Key, Compare, Allocator > & x, const flat_multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator!=(const flat_multiset< Key, Compare, Allocator > & x, const flat_multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator>(const flat_multiset< Key, Compare, Allocator > & x, const flat_multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator<=(const flat_multiset< Key, Compare, Allocator > & x, const flat_multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator>=(const flat_multiset< Key, Compare, Allocator > & x, const flat_multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> void swap(flat_multiset< Key, Compare, Allocator > & x, flat_multiset< Key, Compare, Allocator > & y); } }
namespace boost { namespace container { template<typename T, typename Allocator> bool operator==(const list< T, Allocator > & x, const list< T, Allocator > & y); template<typename T, typename Allocator> bool operator<(const list< T, Allocator > & x, const list< T, Allocator > & y); template<typename T, typename Allocator> bool operator!=(const list< T, Allocator > & x, const list< T, Allocator > & y); template<typename T, typename Allocator> bool operator>(const list< T, Allocator > & x, const list< T, Allocator > & y); template<typename T, typename Allocator> bool operator<=(const list< T, Allocator > & x, const list< T, Allocator > & y); template<typename T, typename Allocator> bool operator>=(const list< T, Allocator > & x, const list< T, Allocator > & y); template<typename T, typename Allocator> void swap(list< T, Allocator > & x, list< T, Allocator > & y); } }
namespace boost { namespace container { template<typename Key, typename T, typename Compare, typename Allocator> bool operator==(const map< Key, T, Compare, Allocator > & x, const map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator<(const map< Key, T, Compare, Allocator > & x, const map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator!=(const map< Key, T, Compare, Allocator > & x, const map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator>(const map< Key, T, Compare, Allocator > & x, const map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator<=(const map< Key, T, Compare, Allocator > & x, const map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator>=(const map< Key, T, Compare, Allocator > & x, const map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> void swap(map< Key, T, Compare, Allocator > & x, map< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator==(const multimap< Key, T, Compare, Allocator > & x, const multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator<(const multimap< Key, T, Compare, Allocator > & x, const multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator!=(const multimap< Key, T, Compare, Allocator > & x, const multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator>(const multimap< Key, T, Compare, Allocator > & x, const multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator<=(const multimap< Key, T, Compare, Allocator > & x, const multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> bool operator>=(const multimap< Key, T, Compare, Allocator > & x, const multimap< Key, T, Compare, Allocator > & y); template<typename Key, typename T, typename Compare, typename Allocator> void swap(multimap< Key, T, Compare, Allocator > & x, multimap< Key, T, Compare, Allocator > & y); } }
namespace boost { namespace container { 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, const scoped_allocator_adaptor< OuterA2, InnerAllocs... > & b); template<typename OuterA1, typename OuterA2, typename... InnerAllocs> bool operator!=(const scoped_allocator_adaptor< OuterA1, InnerAllocs... > & a, const scoped_allocator_adaptor< OuterA2, InnerAllocs... > & b); } }
namespace boost { namespace container { struct allocator_arg_t; static const allocator_arg_t allocator_arg; } }
namespace boost { namespace container { template<typename Key, typename Compare, typename Allocator> bool operator==(const set< Key, Compare, Allocator > & x, const set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator<(const set< Key, Compare, Allocator > & x, const set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator!=(const set< Key, Compare, Allocator > & x, const set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator>(const set< Key, Compare, Allocator > & x, const set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator<=(const set< Key, Compare, Allocator > & x, const set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator>=(const set< Key, Compare, Allocator > & x, const set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> void swap(set< Key, Compare, Allocator > & x, set< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator==(const multiset< Key, Compare, Allocator > & x, const multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator<(const multiset< Key, Compare, Allocator > & x, const multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator!=(const multiset< Key, Compare, Allocator > & x, const multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator>(const multiset< Key, Compare, Allocator > & x, const multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator<=(const multiset< Key, Compare, Allocator > & x, const multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> bool operator>=(const multiset< Key, Compare, Allocator > & x, const multiset< Key, Compare, Allocator > & y); template<typename Key, typename Compare, typename Allocator> void swap(multiset< Key, Compare, Allocator > & x, multiset< Key, Compare, Allocator > & y); } }
namespace boost { namespace container { template<typename T, typename Allocator> bool operator==(const slist< T, Allocator > & x, const slist< T, Allocator > & y); template<typename T, typename Allocator> bool operator<(const slist< T, Allocator > & sL1, const slist< T, Allocator > & sL2); template<typename T, typename Allocator> bool operator!=(const slist< T, Allocator > & sL1, const slist< T, Allocator > & sL2); template<typename T, typename Allocator> bool operator>(const slist< T, Allocator > & sL1, const slist< T, Allocator > & sL2); template<typename T, typename Allocator> bool operator<=(const slist< T, Allocator > & sL1, const slist< T, Allocator > & sL2); template<typename T, typename Allocator> bool operator>=(const slist< T, Allocator > & sL1, const slist< T, Allocator > & sL2); template<typename T, typename Allocator> void swap(slist< T, Allocator > & x, slist< T, Allocator > & y); } }
namespace boost { namespace container { template<typename T, typename Allocator> bool operator==(const stable_vector< T, Allocator > & x, const stable_vector< T, Allocator > & y); template<typename T, typename Allocator> bool operator<(const stable_vector< T, Allocator > & x, const stable_vector< T, Allocator > & y); template<typename T, typename Allocator> bool operator!=(const stable_vector< T, Allocator > & x, const stable_vector< T, Allocator > & y); template<typename T, typename Allocator> bool operator>(const stable_vector< T, Allocator > & x, const stable_vector< T, Allocator > & y); template<typename T, typename Allocator> bool operator>=(const stable_vector< T, Allocator > & x, const stable_vector< T, Allocator > & y); template<typename T, typename Allocator> bool operator<=(const stable_vector< T, Allocator > & x, const stable_vector< T, Allocator > & y); template<typename T, typename Allocator> void swap(stable_vector< T, Allocator > & x, stable_vector< T, Allocator > & y); } }
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 { 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 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 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> 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> 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> 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> 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> 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); } }
namespace boost { namespace container { void throw_bad_alloc(); void throw_out_of_range(const char * str); void throw_length_error(const char * str); void throw_logic_error(const char * str); void throw_runtime_error(const char * str); } }
namespace boost { namespace container { template<typename T, typename Allocator> bool operator==(const vector< T, Allocator > & x, const vector< T, Allocator > & y); template<typename T, typename Allocator> bool operator!=(const vector< T, Allocator > & x, const vector< T, Allocator > & y); template<typename T, typename Allocator> bool operator<(const vector< T, Allocator > & x, const vector< T, Allocator > & y); template<typename T, typename Allocator> void swap(vector< T, Allocator > & x, vector< T, Allocator > & y); } }