Boost.Container Header Reference
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 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 {
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 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);
}
}
template<typename T, typename Allocator = std::allocator<T> > class vector;namespace boost {
namespace container {
vec_iterator();
vec_iterator(vec_iterator< Pointer, false > const & other);
reference operator*();
pointer operator->();
reference operator[](difference_type off);
vec_iterator & operator++();
vec_iterator operator++(int);
vec_iterator & operator--();
vec_iterator operator--(int);
vec_iterator & operator+=(difference_type off);
vec_iterator & operator-=(difference_type off);
friend vec_iterator operator+(const vec_iterator & x, difference_type off);
friend vec_iterator operator+(difference_type off, vec_iterator right);
friend vec_iterator operator-(vec_iterator left, difference_type off);
friend difference_type
operator-(const vec_iterator & left, const vec_iterator & right);
friend bool operator==(const vec_iterator & l, const vec_iterator & r);
friend bool operator!=(const vec_iterator & l, const vec_iterator & r);
friend bool operator<(const vec_iterator & l, const vec_iterator & r);
friend bool operator<=(const vec_iterator & l, const vec_iterator & r);
friend bool operator>(const vec_iterator & l, const vec_iterator & r);
friend bool operator>=(const vec_iterator & l, const vec_iterator & r);
}
}
template<typename Pointer, bool IsConst>
const Pointer & vector_iterator_get_ptr(unspecified it);
template<typename Pointer, bool IsConst> Pointer & get_ptr(unspecified it);
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);