...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
A B C D E F I L M N O P R S T U W X
accept_ownership_type
allocator
allocator_holder
bad_alloc
basic_bufferbuf
basic_bufferstream
basic_ibufferstream
basic_managed_external_buffer
basic_managed_heap_memory
basic_managed_mapped_file
basic_managed_shared_memory
basic_managed_windows_shared_memory
basic_managed_xsi_shared_memory
basic_obufferstream
basic_vectorbuf
basic_vectorstream
create_only_t
defer_lock_type
deleter
enable_shared_from_this
file_lock
file_mapping
flat_map_index_aux
interprocess_condition
interprocess_condition_any
interprocess_exception
interprocess_mutex
interprocess_recursive_mutex
interprocess_semaphore
interprocess_sharable_mutex
interprocess_upgradable_mutex
intrusive_ptr
iset_index_aux
iunordered_set_index_aux
lock_exception
managed_shared_ptr
managed_unique_ptr
managed_weak_ptr
mapped_region
message_queue_t
mutex_family
named_condition
named_condition_any
named_mutex
named_recursive_mutex
named_semaphore
named_sharable_mutex
named_upgradable_mutex
null_index
null_mutex
null_mutex_family
offset_ptr
open_copy_on_write_t
open_only_t
open_or_create_t
open_read_only_t
open_read_private_t
permissions
rbtree_best_fit
remove_file_on_destroy
remove_shared_memory_on_destroy
scoped_lock
scoped_ptr
segment_manager
segment_manager_base
sharable_lock
shared_memory_object
shared_ptr
simple_seq_fit
try_to_lock_type
unique_ptr
unordered_map_index_aux
upgradable_lock
weak_ptr
windows_shared_memory
xsi_key
xsi_shared_memory
A B C D E F I K M N O P R S T V W
allocator_type
deleter
deleter_type
element_type
fixed_managed_shared_memory
ibufferstream
index_aux
index_t
int_type
managed_external_buffer
managed_heap_memory
managed_mapped_file
managed_shared_memory
managed_windows_shared_memory
managed_xsi_shared_memory
mapped_type
memory_algorithm
message_queue
multiallocation_chain
mutex_family
mutex_type
native_error_t
recursive_mutex_type
segment_manager
segment_manager_base
segment_manager_base_type
value_type
vector_type
void_allocator
void_pointer
wbufferbuf
wbufferstream
wfixed_managed_shared_memory
wibufferstream
wmanaged_external_buffer
wmanaged_heap_memory
wmanaged_mapped_file
wmanaged_shared_memory
wmanaged_windows_shared_memory
wmanaged_xsi_shared_memory
wobufferstream
A B C D E F G I L M N O P R S T U W Z
adaptive_pool
advise
allocate
allocate_aligned
allocate_individual
allocate_many
allocate_one
all_memory_deallocated
atomic_func
bad_alloc
basic_managed_external_buffer
basic_managed_heap_memory
basic_managed_shared_memory
basic_managed_windows_shared_memory
basic_managed_xsi_shared_memory
begin
buffer
cached_adaptive_pool
cached_node_allocator
check_sanity
clear
construct
construct_it
data
deallocate
deallocate_free_blocks
deallocate_individual
deallocate_many
deallocate_one
destroy
destroy_ptr
file_mapping
find
find_or_construct
find_or_construct_it
flush
for
get
get_allocator
get_deleter
get_instance_length
get_instance_name
get_instance_type
get_min_size
get_num_named_objects
get_num_unique_objects
get_page_size
grow
if
insert_commit
interprocess_condition
interprocess_condition_any
interprocess_exception
interprocess_mutex
interprocess_recursive_mutex
interprocess_semaphore
interprocess_sharable_mutex
interprocess_upgradable_mutex
intrusive_ptr_add_ref
intrusive_ptr_release
lock
lock_exception
lock_sharable
lock_upgradable
make_managed_shared_ptr
make_managed_unique_ptr
make_managed_weak_ptr
mapped_region
name
named_condition
named_condition_any
named_mutex
named_recursive_mutex
named_semaphore
named_sharable_mutex
named_upgradable_mutex
node_allocator
notify_all
notify_one
null_index
null_mutex
offset_ptr
pointer_to
post
pred
private_adaptive_pool
private_node_allocator
rbtree_best_fit
receive
release
remove
reserve
reserve_named_objects
reserve_unique_objects
reset
scoped_ptr
segment_manager
send
set_default
set_max_cached_nodes
set_permissions
set_unrestricted
sharable_lock
shrink_by
shrink_to_fit
shrink_to_fit_indexes
swap
swap_vector
timed_lock
timed_lock_sharable
timed_lock_upgradable
timed_receive
timed_send
timed_unlock_upgradable_and_lock
timed_wait
to_raw_pointer
truncate
try_atomic_func
try_lock
try_lock_sharable
try_lock_upgradable
try_receive
try_send
try_unlock_sharable_and_lock
try_unlock_sharable_and_lock_upgradable
try_unlock_upgradable_and_lock
try_wait
unique_ptr
unlock
unlock_and_lock_sharable
unlock_and_lock_upgradable
unlock_sharable
unlock_upgradable
unlock_upgradable_and_lock
unlock_upgradable_and_lock_sharable
upgradable_lock
wait
while
zero_free_memory
Describes adaptive_pool pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> bool operator==(const adaptive_pool< T, S, NodesPerBlock, F, OP > &, const adaptive_pool< T, S, NodesPerBlock, F, OP > &); template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> bool operator!=(const adaptive_pool< T, S, NodesPerBlock, F, OP > &, const adaptive_pool< T, S, NodesPerBlock, 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> 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 S, std::size_t NodesPerBlock, std::size_t F, std::size_t OP> bool operator==(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &, const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &); template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, std::size_t OP> bool operator!=(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &, const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &); } }
Describes cached_cached_node_allocator pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename S, std::size_t NPC> bool operator==(const cached_node_allocator< T, S, NPC > &, const cached_node_allocator< T, S, NPC > &); template<typename T, typename S, std::size_t NPC> bool operator!=(const cached_node_allocator< T, S, NPC > &, const cached_node_allocator< T, S, NPC > &); } }
Describes node_allocator pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename S, std::size_t NPC> bool operator==(const node_allocator< T, S, NPC > &, const node_allocator< T, S, NPC > &); template<typename T, typename S, std::size_t NPC> bool operator!=(const node_allocator< T, S, NPC > &, const node_allocator< T, S, NPC > &); } }
Describes private_adaptive_pool_base pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> bool operator==(const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &, const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &); template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> bool operator!=(const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &, const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &); } }
Describes private_node_allocator_base pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> bool operator==(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, const private_node_allocator< T, S, NodesPerBlock, F, OP > &); template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> bool operator!=(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, const private_node_allocator< T, S, NodesPerBlock, F, OP > &); } }
Describes a function that creates anonymous shared memory that can be shared between forked processes
namespace boost { namespace interprocess { mapped_region anonymous_shared_memory(std::size_t, void * = 0); } }
namespace boost { namespace interprocess { struct create_only_t; struct open_only_t; struct open_read_only_t; struct open_read_private_t; struct open_copy_on_write_t; struct open_or_create_t; static const create_only_t create_only; static const open_only_t open_only; static const open_read_only_t open_read_only; static const open_or_create_t open_or_create; static const open_copy_on_write_t open_copy_on_write; } }
Describes the error numbering of interprocess classes
namespace boost { namespace interprocess { enum error_code_t { no_error = = 0, system_error, other_error, security_error, read_only_error, io_error, path_error, not_found_error, busy_error, already_exists_error, not_empty_error, is_directory_error, out_of_space_error, out_of_memory_error, out_of_resource_error, lock_error, sem_error, mode_error, size_error, corrupted_error, not_such_file_or_directory, invalid_argument, timeout_when_locking_error, timeout_when_waiting_error }; typedef int native_error_t; } }
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; class remove_file_on_destroy; } }
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; } }
Describes index adaptor of boost::intrusive::set container, to use it as name/shared memory index
Describes index adaptor of boost::intrusive::unordered_set container, to use it as name/shared memory index
Describes index adaptor of boost::map container, to use it as name/shared memory 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.
Describes index adaptor of boost::unordered_map container, to use it as name/shared memory index
namespace boost { namespace interprocess { template<typename Mutex> class scoped_lock; template<typename SharableMutex> class sharable_lock; template<typename UpgradableMutex> class upgradable_lock; template<typename T, typename SegmentManager> class allocator; template<typename T, typename SegmentManager, std::size_t NodesPerBlock = 64> class node_allocator; template<typename T, typename SegmentManager, std::size_t NodesPerBlock = 64> class private_node_allocator; template<typename T, typename SegmentManager, std::size_t NodesPerBlock = 64> class cached_node_allocator; template<typename T, typename SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, unsigned char OverheadPercent = 5> class adaptive_pool; template<typename T, typename SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, unsigned char OverheadPercent = 5> class private_adaptive_pool; template<typename T, typename SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, unsigned char OverheadPercent = 5> class cached_adaptive_pool; template<typename T, typename DifferenceType = std::ptrdiff_t, typename OffsetType = std::size_t, std::size_t Alignment = offset_type_alignment> class offset_ptr; template<typename MutexFamily, typename VoidMutex = offset_ptr<void> > class simple_seq_fit; template<typename MutexFamily, typename VoidMutex = offset_ptr<void>, std::size_t MemAlignment = 0> class rbtree_best_fit; template<typename IndexConfig> class flat_map_index; template<typename IndexConfig> class iset_index; template<typename IndexConfig> class iunordered_set_index; template<typename IndexConfig> class map_index; template<typename IndexConfig> class null_index; template<typename IndexConfig> class unordered_map_index; template<typename CharType, typename MemoryAlgorithm, template< class IndexConfig > class IndexType> class segment_manager; template<typename CharType, typename MemoryAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_external_buffer; template<typename CharType, typename MemoryAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_shared_memory; template<typename CharType, typename MemoryAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_windows_shared_memory; template<typename CharType, typename MemoryAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_xsi_shared_memory; template<typename CharType, typename MemoryAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_heap_memory; template<typename CharType, typename MemoryAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_mapped_file; template<typename CharT, typename CharTraits = std::char_traits<CharT> > class basic_bufferbuf; template<typename CharT, typename CharTraits = std::char_traits<CharT> > class basic_ibufferstream; template<typename CharT, typename CharTraits = std::char_traits<CharT> > class basic_obufferstream; template<typename CharT, typename CharTraits = std::char_traits<CharT> > class basic_bufferstream; template<typename CharVector, typename CharTraits = std::char_traits<typename CharVector::value_type> > class basic_vectorbuf; template<typename CharVector, typename CharTraits = std::char_traits<typename CharVector::value_type> > class basic_ivectorstream; template<typename CharVector, typename CharTraits = std::char_traits<typename CharVector::value_type> > class basic_ovectorstream; template<typename CharVector, typename CharTraits = std::char_traits<typename CharVector::value_type> > class basic_vectorstream; template<typename T, typename Deleter> class scoped_ptr; template<typename T, typename VoidPointer> class intrusive_ptr; template<typename T, typename VoidAllocator, typename Deleter> class shared_ptr; template<typename T, typename VoidAllocator, typename Deleter> class weak_ptr; template<typename VoidPointer> class message_queue_t; 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_windows_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_windows_shared_memory; typedef basic_managed_windows_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_windows_shared_memory; typedef basic_managed_xsi_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_xsi_shared_memory; typedef basic_managed_xsi_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_xsi_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 message_queue_t< offset_ptr< void > > message_queue; static const std::size_t offset_type_alignment; } }
Describes an inter-process message queue. This class allows sending messages between processes and allows blocking, non-blocking and timed sending and receiving.
Describes a named user memory allocation user class.
Describes a named heap memory allocation user class.
Describes mapped region class
BOOST_INTERPROCESS_MAP_NOSYNC
namespace boost { namespace interprocess { class mapped_region; } }
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.
Describes sequential fit algorithm used to allocate objects in shared memory.
Describes a smart pointer that stores the offset between this pointer and target pointee, called offset_ptr.
BOOST_INTERPROCESS_OFFSET_PTR_INLINE_TO_PTR BOOST_INTERPROCESS_OFFSET_PTR_BRANCHLESS_TO_PTR BOOST_INTERPROCESS_OFFSET_PTR_INLINE_TO_OFF BOOST_INTERPROCESS_OFFSET_PTR_BRANCHLESS_TO_OFF BOOST_INTERPROCESS_OFFSET_PTR_INLINE_TO_OFF_FROM_OTHER BOOST_INTERPROCESS_OFFSET_PTR_BRANCHLESS_TO_OFF_FROM_OTHER
namespace boost { template<typename T> struct has_trivial_constructor; template<typename T> struct has_trivial_destructor; namespace interprocess { template<typename E, typename T, typename W, typename X, typename Y, std::size_t Z> std::basic_ostream< E, T > & operator<<(std::basic_ostream< E, T > &, offset_ptr< W, X, Y, Z > const &); template<typename E, typename T, typename W, typename X, typename Y, std::size_t Z> std::basic_istream< E, T > & operator>>(std::basic_istream< E, T > &, offset_ptr< W, X, Y, Z > &); // Simulation of static_cast between pointers. Never throws. template<typename T1, typename P1, typename O1, std::size_t A1, typename T2, typename P2, typename O2, std::size_t A2> boost::interprocess::offset_ptr< T1, P1, O1, A1 > static_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r); // Simulation of const_cast between pointers. Never throws. template<typename T1, typename P1, typename O1, std::size_t A1, typename T2, typename P2, typename O2, std::size_t A2> boost::interprocess::offset_ptr< T1, P1, O1, A1 > const_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r); // Simulation of dynamic_cast between pointers. Never throws. template<typename T1, typename P1, typename O1, std::size_t A1, typename T2, typename P2, typename O2, std::size_t A2> boost::interprocess::offset_ptr< T1, P1, O1, A1 > dynamic_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r); // Simulation of reinterpret_cast between pointers. Never throws. template<typename T1, typename P1, typename O1, std::size_t A1, typename T2, typename P2, typename O2, std::size_t A2> boost::interprocess::offset_ptr< T1, P1, O1, A1 > reinterpret_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r); } }
Describes permissions class
namespace boost { namespace interprocess { class permissions; } }
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; } }
Describes a shared memory object management class.
namespace boost { namespace interprocess { class shared_memory_object; class remove_shared_memory_on_destroy; } }
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 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 to_raw_pointer(intrusive_ptr< T, VP >); } }
Describes the smart pointer scoped_ptr
namespace boost { namespace interprocess { 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 to_raw_pointer(scoped_ptr< T, D > const &); } }
Describes the smart pointer shared_ptr
namespace boost { namespace interprocess { 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 * to_raw_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 &); template<typename T, typename ManagedMemory> managed_shared_ptr< T, ManagedMemory >::type make_managed_shared_ptr(T *, ManagedMemory &, std::nothrow_t); } }
Describes the smart pointer unique_ptr
namespace boost { namespace interprocess { template<typename T, typename D> class unique_ptr; 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> managed_unique_ptr< T, ManagedMemory >::type make_managed_unique_ptr(T *, ManagedMemory &); } }
Describes the smart pointer weak_ptr.
namespace boost { namespace interprocess { 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 { 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 std; } }
Describes a class that wraps file locking capabilities.
namespace boost { namespace interprocess { class file_lock; } }
Describes process-shared variables interprocess_condition class
namespace boost { namespace interprocess { class interprocess_condition; } namespace posix_time { } }
Describes process-shared variables interprocess_condition_any class
namespace boost { namespace interprocess { class interprocess_condition_any; } namespace posix_time { } }
Describes a mutex class that can be placed in memory shared by several processes.
namespace boost { namespace interprocess { class interprocess_mutex; } }
Describes interprocess_recursive_mutex and shared_recursive_try_mutex classes
namespace boost { namespace interprocess { class interprocess_recursive_mutex; } }
Describes a interprocess_semaphore class for inter-process synchronization
namespace boost { namespace interprocess { class interprocess_semaphore; } }
Describes interprocess_sharable_mutex class
namespace boost { namespace interprocess { class interprocess_sharable_mutex; } }
Describes interprocess_upgradable_mutex class
namespace boost { namespace interprocess { class interprocess_upgradable_mutex; } }
Describes the lock options with associated with interprocess_mutex lock constructors.
namespace boost { namespace interprocess { struct defer_lock_type; struct try_to_lock_type; struct accept_ownership_type; static const defer_lock_type defer_lock; static const try_to_lock_type try_to_lock; static const accept_ownership_type accept_ownership; } namespace posix_time { } }
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 a named condition class for inter-process synchronization
namespace boost { namespace interprocess { class named_condition; } }
Describes a named condition class for inter-process synchronization
namespace boost { namespace interprocess { class named_condition_any; } }
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 sharable mutex class for inter-process synchronization
namespace boost { namespace interprocess { class named_sharable_mutex; } }
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.
Describes the upgradable_lock class that serves to acquire the upgradable lock of a mutex.
Describes the upgradable_lock class that serves to acquire the upgradable lock of a mutex.
Describes a class representing a native windows shared memory.
namespace boost { namespace interprocess { class windows_shared_memory; } }
Describes a class representing a xsi key type.
namespace boost { namespace interprocess { class xsi_key; } }
Describes a class representing a native xsi shared memory.
namespace boost { namespace interprocess { class xsi_shared_memory; } }