...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
Describes adaptive_pool pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename SegmentManager, std::size_t NodesPerChunk, std::size_t MaxFreeChunks, unsigned char OverheadPercent> class adaptive_pool; template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, unsigned char OP> bool operator==(const adaptive_pool< T, S, NodesPerChunk, F, OP > &, const adaptive_pool< T, S, NodesPerChunk, F, OP > &); template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, unsigned char OP> bool operator!=(const adaptive_pool< T, S, NodesPerChunk, F, OP > &, const adaptive_pool< T, S, NodesPerChunk, F, OP > &); } }
Describes an allocator that allocates portions of fixed size memory buffer (shared memory, mapped file...)
namespace boost { namespace interprocess { template<typename T, typename SegmentManager> class allocator; template<typename T, typename SegmentManager> bool operator==(const allocator< T, SegmentManager > &, const allocator< T, SegmentManager > &); template<typename T, typename SegmentManager> bool operator!=(const allocator< T, SegmentManager > &, const allocator< T, SegmentManager > &); } }
Describes cached_adaptive_pool pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename SegmentManager, std::size_t NodesPerChunk, std::size_t MaxFreeChunks, unsigned char OverheadPercent> class cached_adaptive_pool; template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, std::size_t OP> bool operator==(const cached_adaptive_pool< T, S, NodesPerChunk, F, OP > &, const cached_adaptive_pool< T, S, NodesPerChunk, F, OP > &); template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, std::size_t OP> bool operator!=(const cached_adaptive_pool< T, S, NodesPerChunk, F, OP > &, const cached_adaptive_pool< T, S, NodesPerChunk, F, OP > &); } }
Describes cached_cached_node_allocator pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename SegmentManager, std::size_t NodesPerChunk> class cached_node_allocator; template<typename T, typename S, std::size_t NodesPerChunk> bool operator==(const cached_node_allocator< T, S, NodesPerChunk > &, const cached_node_allocator< T, S, NodesPerChunk > &); template<typename T, typename S, std::size_t NodesPerChunk> bool operator!=(const cached_node_allocator< T, S, NodesPerChunk > &, const cached_node_allocator< T, S, NodesPerChunk > &); } }
Describes node_allocator pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename SegmentManager, std::size_t NodesPerChunk> class node_allocator; template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, unsigned char OP> bool operator==(const node_allocator< T, S, NodesPerChunk, F, OP > &, const node_allocator< T, S, NodesPerChunk, F, OP > &); template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, unsigned char OP> bool operator!=(const node_allocator< T, S, NodesPerChunk, F, OP > &, const node_allocator< T, S, NodesPerChunk, F, OP > &); } }
Describes private_adaptive_pool_base pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename SegmentManager, std::size_t NodesPerChunk, std::size_t MaxFreeChunks, unsigned char OverheadPercent> class private_adaptive_pool; template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, unsigned char OP> bool operator==(const private_adaptive_pool< T, S, NodesPerChunk, F, OP > &, const private_adaptive_pool< T, S, NodesPerChunk, F, OP > &); template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, unsigned char OP> bool operator!=(const private_adaptive_pool< T, S, NodesPerChunk, F, OP > &, const private_adaptive_pool< T, S, NodesPerChunk, F, OP > &); } }
Describes private_node_allocator_base pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename SegmentManager, std::size_t NodesPerChunk> class private_node_allocator; template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, unsigned char OP> bool operator==(const private_node_allocator< T, S, NodesPerChunk, F, OP > &, const private_node_allocator< T, S, NodesPerChunk, F, OP > &); template<typename T, typename S, std::size_t NodesPerChunk, std::size_t F, unsigned char OP> bool operator!=(const private_node_allocator< T, S, NodesPerChunk, F, OP > &, const private_node_allocator< T, S, NodesPerChunk, F, OP > &); } }
namespace boost { namespace interprocess { template<typename T, typename Alloc> class deque; template<typename T, typename Alloc> bool operator==(const deque< T, Alloc > & x, const deque< T, Alloc > & y); template<typename T, typename Alloc> bool operator<(const deque< T, Alloc > & x, const deque< T, Alloc > & y); template<typename T, typename Alloc> bool operator!=(const deque< T, Alloc > & x, const deque< T, Alloc > & y); template<typename T, typename Alloc> bool operator>(const deque< T, Alloc > & x, const deque< T, Alloc > & y); template<typename T, typename Alloc> bool operator<=(const deque< T, Alloc > & x, const deque< T, Alloc > & y); template<typename T, typename Alloc> bool operator>=(const deque< T, Alloc > & x, const deque< T, Alloc > & y); template<typename T, typename Alloc> void swap(deque< T, Alloc > & x, deque< T, Alloc > & y); } }
namespace boost { namespace interprocess { template<typename Key, typename T, typename Pred, typename Alloc> bool operator==(const flat_map< Key, T, Pred, Alloc > & x, const flat_map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator<(const flat_map< Key, T, Pred, Alloc > & x, const flat_map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator!=(const flat_map< Key, T, Pred, Alloc > & x, const flat_map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator>(const flat_map< Key, T, Pred, Alloc > & x, const flat_map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator<=(const flat_map< Key, T, Pred, Alloc > & x, const flat_map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator>=(const flat_map< Key, T, Pred, Alloc > & x, const flat_map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(flat_map< Key, T, Pred, Alloc > & x, flat_map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(unspecified x, flat_map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(flat_map< Key, T, Pred, Alloc > & x, unspecified y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator==(const flat_multimap< Key, T, Pred, Alloc > & x, const flat_multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator<(const flat_multimap< Key, T, Pred, Alloc > & x, const flat_multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator!=(const flat_multimap< Key, T, Pred, Alloc > & x, const flat_multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator>(const flat_multimap< Key, T, Pred, Alloc > & x, const flat_multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator<=(const flat_multimap< Key, T, Pred, Alloc > & x, const flat_multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator>=(const flat_multimap< Key, T, Pred, Alloc > & x, const flat_multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(flat_multimap< Key, T, Pred, Alloc > & x, flat_multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(unspecified x, flat_multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(flat_multimap< Key, T, Pred, Alloc > & x, unspecified y); } }
namespace boost { namespace interprocess { template<typename T, typename Pred, typename Alloc> bool operator==(const flat_set< T, Pred, Alloc > & x, const flat_set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator<(const flat_set< T, Pred, Alloc > & x, const flat_set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator!=(const flat_set< T, Pred, Alloc > & x, const flat_set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator>(const flat_set< T, Pred, Alloc > & x, const flat_set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator<=(const flat_set< T, Pred, Alloc > & x, const flat_set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator>=(const flat_set< T, Pred, Alloc > & x, const flat_set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(flat_set< T, Pred, Alloc > & x, flat_set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(unspecified x, flat_set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(flat_set< T, Pred, Alloc > & x, unspecified y); template<typename T, typename Pred, typename Alloc> bool operator==(const flat_multiset< T, Pred, Alloc > & x, const flat_multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator<(const flat_multiset< T, Pred, Alloc > & x, const flat_multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator!=(const flat_multiset< T, Pred, Alloc > & x, const flat_multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator>(const flat_multiset< T, Pred, Alloc > & x, const flat_multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator<=(const flat_multiset< T, Pred, Alloc > & x, const flat_multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator>=(const flat_multiset< T, Pred, Alloc > & x, const flat_multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(flat_multiset< T, Pred, Alloc > & x, flat_multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(unspecified x, flat_multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(flat_multiset< T, Pred, Alloc > & x, unspecified y); } }
namespace boost { namespace interprocess { template<typename T, typename A> 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 A> void swap(unspecified x, list< T, A > & y); template<typename T, typename A> void swap(list< T, A > & x, unspecified y); } }
namespace boost { namespace interprocess { template<typename Key, typename T, typename Pred, typename Alloc> class map; template<typename Key, typename T, typename Pred, typename Alloc> class multimap; template<typename Key, typename T, typename Pred, typename Alloc> bool operator==(const map< Key, T, Pred, Alloc > & x, const map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator<(const map< Key, T, Pred, Alloc > & x, const map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator!=(const map< Key, T, Pred, Alloc > & x, const map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator>(const map< Key, T, Pred, Alloc > & x, const map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator<=(const map< Key, T, Pred, Alloc > & x, const map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator>=(const map< Key, T, Pred, Alloc > & x, const map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(map< Key, T, Pred, Alloc > & x, map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(unspecified x, map< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(map< Key, T, Pred, Alloc > & x, unspecified y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator==(const multimap< Key, T, Pred, Alloc > & x, const multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator<(const multimap< Key, T, Pred, Alloc > & x, const multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator!=(const multimap< Key, T, Pred, Alloc > & x, const multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator>(const multimap< Key, T, Pred, Alloc > & x, const multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator<=(const multimap< Key, T, Pred, Alloc > & x, const multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> bool operator>=(const multimap< Key, T, Pred, Alloc > & x, const multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(multimap< Key, T, Pred, Alloc > & x, multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(unspecified x, multimap< Key, T, Pred, Alloc > & y); template<typename Key, typename T, typename Pred, typename Alloc> void swap(multimap< Key, T, Pred, Alloc > & x, unspecified y); } }
namespace boost { namespace interprocess { template<typename T, typename Pred, typename Alloc> bool operator==(const set< T, Pred, Alloc > & x, const set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator<(const set< T, Pred, Alloc > & x, const set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator!=(const set< T, Pred, Alloc > & x, const set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator>(const set< T, Pred, Alloc > & x, const set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator<=(const set< T, Pred, Alloc > & x, const set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator>=(const set< T, Pred, Alloc > & x, const set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(set< T, Pred, Alloc > & x, set< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(set< T, Pred, Alloc > & x, unspecified y); template<typename T, typename Pred, typename Alloc> void swap(unspecified y, set< T, Pred, Alloc > & x); template<typename T, typename Pred, typename Alloc> bool operator==(const multiset< T, Pred, Alloc > & x, const multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator<(const multiset< T, Pred, Alloc > & x, const multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator!=(const multiset< T, Pred, Alloc > & x, const multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator>(const multiset< T, Pred, Alloc > & x, const multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator<=(const multiset< T, Pred, Alloc > & x, const multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> bool operator>=(const multiset< T, Pred, Alloc > & x, const multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(multiset< T, Pred, Alloc > & x, multiset< T, Pred, Alloc > & y); template<typename T, typename Pred, typename Alloc> void swap(multiset< T, Pred, Alloc > & x, unspecified y); template<typename T, typename Pred, typename Alloc> void swap(unspecified y, multiset< T, Pred, Alloc > & x); } }
namespace boost { namespace interprocess { template<typename T, typename A> 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 A> void swap(unspecified x, slist< T, A > & y); template<typename T, typename A> void swap(slist< T, A > & x, unspecified y); } }namespace std { template<typename T, typename A> class insert_iterator<boost::interprocess::slist< T, A >>; }
namespace boost { namespace interprocess { template<typename CharT, typename Traits, typename A> class basic_string; 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> unspecified operator+(unspecified mx, const basic_string< CharT, Traits, A > & y); template<typename CharT, typename Traits, typename A> unspecified operator+(const basic_string< CharT, Traits, A > & x, unspecified 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> unspecified operator+(const CharT * s, unspecified 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> unspecified operator+(CharT c, unspecified 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> unspecified operator+(unspecified 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> unspecified operator+(unspecified 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, 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, 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, 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, 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, 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, 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> void swap(unspecified mx, basic_string< CharT, Traits, A > & y); template<typename CharT, typename Traits, typename A> void swap(basic_string< CharT, Traits, A > & x, unspecified my); template<typename CharT, typename Traits, typename A> 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> std::basic_ostream< CharT, Traits > & operator<<(std::basic_ostream< CharT, Traits > & os, unspecified ms); template<typename CharT, typename Traits, typename A> 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> std::basic_istream< CharT, Traits > & operator>>(std::basic_istream< CharT, Traits > & is, unspecified ms); template<typename CharT, typename Traits, typename A> std::basic_istream< CharT, Traits > & getline(std::istream & is, basic_string< CharT, Traits, A > & s, CharT delim); template<typename CharT, typename Traits, typename A> std::basic_istream< CharT, Traits > & getline(std::istream & is, unspecified ms, CharT delim); template<typename CharT, typename Traits, typename A> std::basic_istream< CharT, Traits > & getline(std::basic_istream< CharT, Traits > & is, basic_string< CharT, Traits, A > & s); template<typename CharT, typename Traits, typename A> std::basic_istream< CharT, Traits > & getline(std::istream & is, unspecified ms); template<typename Ch, typename A> std::size_t hash_value(basic_string< Ch, std::char_traits< Ch >, A > const & v); } }
namespace boost { namespace interprocess { template<typename T, typename A> 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, typename A> void swap(unspecified x, vector< T, A > & y); template<typename T, typename A> void swap(vector< T, A > & x, unspecified y); } }
namespace boost { namespace interprocess { struct create_only_t; struct open_only_t; struct open_or_create_t; static const create_only_t create_only; static const open_only_t open_only; static const open_or_create_t open_or_create; } }
Describes exceptions thrown by interprocess classes
namespace boost { namespace interprocess { class interprocess_exception; class lock_exception; class bad_alloc; } }
Describes file_mapping and mapped region classes
namespace boost { namespace interprocess { class file_mapping; } }
Describes index adaptor of boost::map container, to use it as name/shared memory index
namespace boost { namespace interprocess { template<typename MapConfig> struct flat_map_index_aux; template<typename MapConfig> class flat_map_index; } }
Describes index adaptor of boost::intrusive::set container, to use it as name/shared memory index
namespace boost { namespace interprocess { template<typename MapConfig> class iset_index; } }
Describes index adaptor of boost::intrusive::unordered_set container, to use it as name/shared memory index
namespace boost { namespace interprocess { template<typename MapConfig> class iunordered_set_index; } }
Describes index adaptor of boost::map container, to use it as name/shared memory index
namespace boost { namespace interprocess { template<typename MapConfig> class map_index; } }
Describes a null index adaptor, so that if we don't want to construct named objects, we can use this null index type to save resources.
namespace boost { namespace interprocess { template<typename MapConfig> class null_index; } }
Describes index adaptor of boost::unordered_map container, to use it as name/shared memory index
namespace boost { namespace interprocess { template<typename MapConfig> struct unordered_map_index_aux; template<typename MapConfig> class unordered_map_index; } }
namespace boost { namespace interprocess { typedef basic_managed_external_buffer< char,rbtree_best_fit< null_mutex_family >,iset_index > managed_external_buffer; typedef basic_managed_external_buffer< wchar_t,rbtree_best_fit< null_mutex_family >,iset_index > wmanaged_external_buffer; typedef basic_managed_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_shared_memory; typedef basic_managed_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_shared_memory; typedef basic_managed_shared_memory< char,rbtree_best_fit< mutex_family, void * >,iset_index > fixed_managed_shared_memory; typedef basic_managed_shared_memory< wchar_t,rbtree_best_fit< mutex_family, void * >,iset_index > wfixed_managed_shared_memory; typedef basic_managed_heap_memory< char,rbtree_best_fit< null_mutex_family >,iset_index > managed_heap_memory; typedef basic_managed_heap_memory< wchar_t,rbtree_best_fit< null_mutex_family >,iset_index > wmanaged_heap_memory; typedef basic_managed_mapped_file< char,rbtree_best_fit< mutex_family >,iset_index > managed_mapped_file; typedef basic_managed_mapped_file< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_mapped_file; typedef basic_string< char,std::char_traits< char >,std::allocator< char > > string; } }
Describes an inter-process message queue. This class allows sending messages between processes and allows blocking, non-blocking and timed sending and receiving.
namespace boost { namespace interprocess { class message_queue; } }
Describes a named user memory allocation user class.
namespace boost { namespace interprocess { template<typename CharType, typename AllocationAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_external_buffer; } }
Describes a named heap memory allocation user class.
namespace boost { namespace interprocess { template<typename CharType, typename AllocationAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_heap_memory; } }
Describes a named shared memory object allocation user class.
namespace boost { namespace interprocess { template<typename CharType, typename AllocationAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_mapped_file; } }
Describes a named shared memory object allocation user class.
namespace boost { namespace interprocess { template<typename CharType, typename AllocationAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_shared_memory; } }
Describes a named shared memory object allocation user class.
namespace boost { namespace interprocess { template<typename CharType, typename AllocationAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_windows_shared_memory; } }
Describes memory_mappable and mapped region classes
namespace boost { namespace interprocess { class mapped_region; void swap(mapped_region & x, mapped_region & y); } }
Describes a best-fit algorithm based in an intrusive red-black tree used to allocate objects in shared memory. This class is intended as a base class for single segment and multi-segment implementations.
namespace boost { namespace interprocess { template<typename MutexFamily, typename VoidPointer, std::size_t MemAlignment> class rbtree_best_fit; } }
Describes sequential fit algorithm used to allocate objects in shared memory.
namespace boost { namespace interprocess { template<typename MutexFamily, typename VoidPointer> class simple_seq_fit; } }
Describes a smart pointer that stores the offset between this pointer and target pointee, called offset_ptr.
namespace boost { namespace interprocess { template<typename PointedType> class offset_ptr; template<typename T1, typename T2> bool operator==(const offset_ptr< T1 > &, const offset_ptr< T2 > &); template<typename T1, typename T2> bool operator!=(const offset_ptr< T1 > &, const offset_ptr< T2 > &); template<typename T1, typename T2> bool operator<(const offset_ptr< T1 > &, const offset_ptr< T2 > &); template<typename T1, typename T2> bool operator<=(const offset_ptr< T1 > &, const offset_ptr< T2 > &); template<typename T1, typename T2> bool operator>(const offset_ptr< T1 > &, const offset_ptr< T2 > &); template<typename T1, typename T2> bool operator>=(const offset_ptr< T1 > &, const offset_ptr< T2 > &); template<typename E, typename T, typename Y> std::basic_ostream< E, T > & operator<<(std::basic_ostream< E, T > &, offset_ptr< Y > const &); template<typename E, typename T, typename Y> std::basic_istream< E, T > & operator>>(std::basic_istream< E, T > &, offset_ptr< Y > &); template<typename T> offset_ptr< T > operator+(std::ptrdiff_t, const offset_ptr< T > &); template<typename T, typename T2> std::ptrdiff_t operator-(const offset_ptr< T > &, const offset_ptr< T2 > &); template<typename T> void swap(boost::interprocess::offset_ptr< T > &, boost::interprocess::offset_ptr< T > &); // Simulation of static_cast between pointers. Never throws. template<typename T, typename U> boost::interprocess::offset_ptr< T > static_pointer_cast(boost::interprocess::offset_ptr< U > const & r); // Simulation of const_cast between pointers. Never throws. template<typename T, typename U> boost::interprocess::offset_ptr< T > const_pointer_cast(boost::interprocess::offset_ptr< U > const & r); // Simulation of dynamic_cast between pointers. Never throws. template<typename T, typename U> boost::interprocess::offset_ptr< T > dynamic_pointer_cast(boost::interprocess::offset_ptr< U > const & r); // Simulation of reinterpret_cast between pointers. Never throws. template<typename T, typename U> boost::interprocess::offset_ptr< T > reinterpret_pointer_cast(boost::interprocess::offset_ptr< U > const & r); } }
Describes the object placed in a memory segment that provides named object allocation capabilities for single-segment and multi-segment allocations.
namespace boost { namespace interprocess { template<typename MemoryAlgorithm> class segment_manager_base; template<typename CharType, typename MemoryAlgorithm, template< class IndexConfig > class IndexType> class segment_manager; static unspecified anonymous_instance; static unspecified unique_instance; } }
Describes a shared memory object management class.
namespace boost { namespace interprocess { class shared_memory_object; } }
Describes the functor to delete objects from the segment.
namespace boost { namespace interprocess { template<typename T, typename SegmentManager> class deleter; } }
Describes an utility to form a shared pointer from this
namespace boost { namespace interprocess { template<typename T, typename A, typename D> class enable_shared_from_this; } }
Describes an intrusive ownership pointer.
namespace boost { namespace interprocess { template<typename T, typename VoidPointer> class intrusive_ptr; template<typename T, typename U, typename VP> bool operator==(intrusive_ptr< T, VP > const &, intrusive_ptr< U, VP > const &); template<typename T, typename U, typename VP> bool operator!=(intrusive_ptr< T, VP > const &, intrusive_ptr< U, VP > const &); template<typename T, typename VP> bool operator==(intrusive_ptr< T, VP > const &, const typename intrusive_ptr< T, VP >::pointer &); template<typename T, typename VP> bool operator!=(intrusive_ptr< T, VP > const &, const typename intrusive_ptr< T, VP >::pointer &); template<typename T, typename VP> bool operator==(const typename intrusive_ptr< T, VP >::pointer &, intrusive_ptr< T, VP > const &); template<typename T, typename VP> bool operator!=(const typename intrusive_ptr< T, VP >::pointer &, intrusive_ptr< T, VP > const &); template<typename T, typename VP> bool operator<(intrusive_ptr< T, VP > const &, intrusive_ptr< T, VP > const &); template<typename T, typename VP> void swap(intrusive_ptr< T, VP > &, intrusive_ptr< T, VP > &); template<typename E, typename T, typename Y, typename VP> std::basic_ostream< E, T > & operator<<(std::basic_ostream< E, T > & os, intrusive_ptr< Y, VP > const & p); template<typename T, typename VP> boost::interprocess::intrusive_ptr< T, VP >::pointer get_pointer(intrusive_ptr< T, VP >); } }
Describes the smart pointer scoped_ptr
namespace boost { namespace interprocess { template<typename T, typename Deleter> class scoped_ptr; template<typename T, typename D> void swap(scoped_ptr< T, D > &, scoped_ptr< T, D > &); template<typename T, typename D> scoped_ptr< T, D >::pointer get_pointer(scoped_ptr< T, D > const &); } }
Describes the smart pointer shared_ptr
namespace boost { namespace interprocess { template<typename T, typename VoidAllocator, typename Deleter> class shared_ptr; template<typename T, typename ManagedMemory> struct managed_shared_ptr; template<typename T, typename VoidAllocator, typename Deleter, typename U, typename VoidAllocator2, typename Deleter2> bool operator==(shared_ptr< T, VoidAllocator, Deleter > const & a, shared_ptr< U, VoidAllocator2, Deleter2 > const & b); template<typename T, typename VoidAllocator, typename Deleter, typename U, typename VoidAllocator2, typename Deleter2> bool operator!=(shared_ptr< T, VoidAllocator, Deleter > const & a, shared_ptr< U, VoidAllocator2, Deleter2 > const & b); template<typename T, typename VoidAllocator, typename Deleter, typename U, typename VoidAllocator2, typename Deleter2> bool operator<(shared_ptr< T, VoidAllocator, Deleter > const & a, shared_ptr< U, VoidAllocator2, Deleter2 > const & b); template<typename T, typename VoidAllocator, typename Deleter> void swap(shared_ptr< T, VoidAllocator, Deleter > & a, shared_ptr< T, VoidAllocator, Deleter > & b); template<typename T, typename VoidAllocator, typename Deleter, typename U> shared_ptr< T, VoidAllocator, Deleter > static_pointer_cast(shared_ptr< U, VoidAllocator, Deleter > const & r); template<typename T, typename VoidAllocator, typename Deleter, typename U> shared_ptr< T, VoidAllocator, Deleter > const_pointer_cast(shared_ptr< U, VoidAllocator, Deleter > const & r); template<typename T, typename VoidAllocator, typename Deleter, typename U> shared_ptr< T, VoidAllocator, Deleter > dynamic_pointer_cast(shared_ptr< U, VoidAllocator, Deleter > const & r); template<typename T, typename VoidAllocator, typename Deleter> T * get_pointer(shared_ptr< T, VoidAllocator, Deleter > const & p); template<typename E, typename T, typename Y, typename VoidAllocator, typename Deleter> std::basic_ostream< E, T > & operator<<(std::basic_ostream< E, T > & os, shared_ptr< Y, VoidAllocator, Deleter > const & p); template<typename T, typename ManagedMemory> managed_shared_ptr< T, ManagedMemory >::type make_managed_shared_ptr(T *, ManagedMemory &); } }
Describes the smart pointer unique_ptr
namespace boost { namespace interprocess { template<typename T, typename ManagedMemory> struct managed_unique_ptr; template<typename T, typename D> void swap(unique_ptr< T, D > & x, unique_ptr< T, D > & y); template<typename T1, typename D1, typename T2, typename D2> bool operator==(const unique_ptr< T1, D1 > & x, const unique_ptr< T2, D2 > & y); template<typename T1, typename D1, typename T2, typename D2> bool operator!=(const unique_ptr< T1, D1 > & x, const unique_ptr< T2, D2 > & y); template<typename T1, typename D1, typename T2, typename D2> bool operator<(const unique_ptr< T1, D1 > & x, const unique_ptr< T2, D2 > & y); template<typename T1, typename D1, typename T2, typename D2> bool operator<=(const unique_ptr< T1, D1 > & x, const unique_ptr< T2, D2 > & y); template<typename T1, typename D1, typename T2, typename D2> bool operator>(const unique_ptr< T1, D1 > & x, const unique_ptr< T2, D2 > & y); template<typename T1, typename D1, typename T2, typename D2> bool operator>=(const unique_ptr< T1, D1 > & x, const unique_ptr< T2, D2 > & y); template<typename T, typename ManagedMemory> unspecified make_managed_unique_ptr(T *, ManagedMemory &); } }
Describes the smart pointer weak_ptr.
namespace boost { namespace interprocess { template<typename T, typename A, typename D> class weak_ptr; template<typename T, typename ManagedMemory> struct managed_weak_ptr; template<typename T, typename A, typename D, typename U, typename A2, typename D2> bool operator<(weak_ptr< T, A, D > const & a, weak_ptr< U, A2, D2 > const & b); template<typename T, typename A, typename D> void swap(weak_ptr< T, A, D > & a, weak_ptr< T, A, D > & b); template<typename T, typename ManagedMemory> managed_weak_ptr< T, ManagedMemory >::type make_managed_weak_ptr(T *, ManagedMemory &); } }
This file defines basic_bufferbuf, basic_ibufferstream, basic_obufferstream, and basic_bufferstream classes. These classes represent streamsbufs and streams whose sources or destinations are fixed size character buffers.
namespace boost { namespace interprocess { template<typename CharT, typename CharTraits> class basic_bufferbuf; template<typename CharT, typename CharTraits> class basic_ibufferstream; template<typename CharT, typename CharTraits> class basic_obufferstream; template<typename CharT, typename CharTraits> class basic_bufferstream; typedef basic_bufferbuf< char > bufferbuf; typedef basic_bufferstream< char > bufferstream; typedef basic_ibufferstream< char > ibufferstream; typedef basic_obufferstream< char > obufferstream; typedef basic_bufferbuf< wchar_t > wbufferbuf; typedef basic_bufferstream< wchar_t > wbufferstream; typedef basic_ibufferstream< wchar_t > wibufferstream; typedef basic_obufferstream< wchar_t > wobufferstream; } }
This file defines basic_vectorbuf, basic_ivectorstream, basic_ovectorstream, and basic_vectorstreamclasses. These classes represent streamsbufs and streams whose sources or destinations are STL-like vectors that can be swapped with external vectors to avoid unnecessary allocations/copies.
namespace boost { namespace interprocess { template<typename CharVector, typename CharTraits> class basic_vectorbuf; template<typename CharVector, typename CharTraits> class basic_ivectorstream; template<typename CharVector, typename CharTraits> class basic_ovectorstream; template<typename CharVector, typename CharTraits> class basic_vectorstream; } }
Describes a class that wraps file locking capabilities.
namespace boost { namespace interprocess { class file_lock; } }
BOOST_INTERPROCESS_USE_GENERIC_EMULATION
namespace boost { namespace interprocess { class barrier; } }
Describes process-shared variables interprocess_condition class
BOOST_INTERPROCESS_USE_GENERIC_EMULATION
namespace boost { namespace interprocess { class interprocess_condition; } namespace posix_time { } }
Describes a mutex class that can be placed in memory shared by several processes.
BOOST_INTERPROCESS_USE_GENERIC_EMULATION
namespace boost { namespace interprocess { class interprocess_mutex; } }
Describes interprocess_recursive_mutex and shared_recursive_try_mutex classes
BOOST_INTERPROCESS_USE_GENERIC_EMULATION
namespace boost { namespace interprocess { class interprocess_recursive_mutex; } }
Describes a interprocess_semaphore class for inter-process synchronization
BOOST_INTERPROCESS_USE_GENERIC_EMULATION
namespace boost { namespace interprocess { class interprocess_semaphore; } }
Describes interprocess_upgradable_mutex class
namespace boost { namespace interprocess { class interprocess_upgradable_mutex; } }
Describes the lock options with associated with interprocess_mutex lock constructors.
Describes a shared interprocess_mutex family fit algorithm used to allocate objects in shared memory.
namespace boost { namespace interprocess { struct mutex_family; struct null_mutex_family; } }
Describes process-shared variables interprocess_condition class
namespace boost { namespace interprocess { class named_condition; } }
Describes a named mutex class for inter-process synchronization
namespace boost { namespace interprocess { class named_mutex; } }
Describes a named named_recursive_mutex class for inter-process synchronization
namespace boost { namespace interprocess { class named_recursive_mutex; } }
Describes a named semaphore class for inter-process synchronization
namespace boost { namespace interprocess { class named_semaphore; } }
Describes a named upgradable mutex class for inter-process synchronization
namespace boost { namespace interprocess { class named_upgradable_mutex; } }
Describes null_mutex classes
namespace boost { namespace interprocess { class null_mutex; } namespace posix_time { } }
Describes the scoped_lock class.
namespace boost { namespace interprocess { template<typename Mutex> class scoped_lock; } }
Describes the upgradable_lock class that serves to acquire the upgradable lock of a mutex.
namespace boost { namespace interprocess { template<typename SharableMutex> class sharable_lock; } }
Describes the upgradable_lock class that serves to acquire the upgradable lock of a mutex.
namespace boost { namespace interprocess { template<typename UpgradableMutex> class upgradable_lock; } }
Describes a class representing a native windows shared memory.
namespace boost { namespace interprocess { class windows_shared_memory; } }