...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_managed_external_buffer
basic_managed_heap_memory
basic_managed_shared_memory
basic_managed_windows_shared_memory
basic_managed_xsi_shared_memory
basic_vectorbuf
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
rebind
scoped_lock
scoped_ptr
segment_manager
segment_manager_base
sharable_lock
shared_memory_object
shared_ptr
simple_seq_fit
try_to_lock_type
upgradable_lock
usduration
ustime
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 U V W
allocator_type
base_type
basic_streambuf_t
bucket_ptr
bucket_traits
bucket_type
bufferbuf
bufferstream
char_ptr
char_type
const_allocator_pointer
const_deleter_pointer
const_iterator
const_named_iterator
const_pointer
const_reference
const_unique_iterator
deleter
deleter_type
difference_type
ibufferstream
index_aux
index_t
insert_commit_data
int_type
iterator
iterator_category
key_less
key_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
obufferstream
offset_type
off_type
other
pointer
pos_type
recursive_mutex_type
reference
segment_manager
segment_manager_base
segment_manager_base_type
size_type
traits_type
type
unspecified_bool_type
value_type
vector_type
version
void_allocator
void_pointer
void_ptr
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 K L M N O P R S T U V W X Z
adaptive_pool
advise
alignment
allocate
allocate_aligned
allocate_many
allocate_one
allocation_command
allocator
all_memory_deallocated
anonymous_shared_memory
APIs
atomic_func
bad_alloc
basic_bufferbuf
basic_vectorbuf
begin
buffer
cached_adaptive_pool
cached_node_allocator
check_sanity
clear
construct
constructor
construct_it
const_pointer_cast
conversion
data
deallocate
deallocate_free_blocks
deallocate_many
deallocate_one
destroy
destroy_ptr
dynamic_pointer_cast
fail
file_lock
file_mapping
find
find_or_construct
find_or_construct_it
flat_map_index
flush
ftok
get
get_allocator
get_deleter
get_instance_length
get_instance_name
get_instance_type
get_memory_algorithm
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
intrusive_ptr_add_ref
iset_index
it
iunordered_set_index
lock
lock_exception
lock_sharable
lock_shared
lock_upgradable
make_managed_shared_ptr
make_managed_unique_ptr
make_managed_weak_ptr
mapped_region
map_index
memory
mutex
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
p
pointer
POSIX
post
pred
private_adaptive_pool
private_node_allocator
raw_allocation_command
rbtree_best_fit
receive
release
remove
reserve
reserve_named_objects
reserve_unique_objects
reset
scoped_lock
segment
segment_manager
segment_manager_base
send
set_max_cached_nodes
sharable_lock
shared_from_this
shared_memory_object
shared_ptr
shrink_to_fit
shrink_to_fit_indexes
size
sizeof
space
static_pointer_cast
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_for
try_lock_sharable
try_lock_shared
try_lock_shared_for
try_lock_shared_until
try_lock_until
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
unlock
unlock_and_lock_sharable
unlock_and_lock_upgradable
unlock_sharable
unlock_shared
unlock_upgradable
unlock_upgradable_and_lock
unlock_upgradable_and_lock_sharable
upgradable_lock
usduration
usduration_from_milliseconds
usduration_from_seconds
use_count
ustime
ustime_delay_milliseconds
wait
wait_for
wait_until
while
windows_shared_memory
xsi_key
xsi_shared_memory
zero_free_memory
Describes adaptive_pool pooled shared memory STL compatible allocator
namespace boost { namespace interprocess { template<typename T, typename SegmentManager, std::size_t NodesPerBlock, std::size_t MaxFreeBlocks, unsigned char OverheadPercent> class adaptive_pool; 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> 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 NodesPerBlock, std::size_t MaxFreeBlocks, unsigned char OverheadPercent> class cached_adaptive_pool; 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 SegmentManager, std::size_t NodesPerBlock> class cached_node_allocator; 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 SegmentManager, std::size_t NodesPerBlock> class node_allocator; 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 SegmentManager, std::size_t NodesPerBlock, std::size_t MaxFreeBlocks, unsigned char OverheadPercent> class private_adaptive_pool; 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 SegmentManager, std::size_t NodesPerBlock> class private_node_allocator; 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_copy_on_write_t; struct open_only_t; struct open_or_create_t; struct open_read_only_t; struct open_read_private_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, owner_dead_error, not_recoverable }; typedef int native_error_t; } }
Describes exceptions thrown by interprocess classes
namespace boost { namespace interprocess { class bad_alloc; class interprocess_exception; class lock_exception; } }
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> 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; } }
This header file forward declares the basic interprocess types:
The following synchronization mechanisms and locks:
The following mutex families:
The following allocators:
The following allocation algorithms:
The following index types:
boost::interprocess::unordered_map_index;
The following managed memory types:
boost::interprocess::managed_shared_memory
boost::interprocess::wmanaged_shared_memory
boost::interprocess::managed_windows_shared_memory
boost::interprocess::wmanaged_windows_shared_memory
boost::interprocess::managed_xsi_shared_memory
boost::interprocess::wmanaged_xsi_shared_memory
boost::interprocess::fixed_managed_shared_memory
boost::interprocess::wfixed_managed_shared_memory
boost::interprocess::managed_mapped_file
boost::interprocess::wmanaged_mapped_file
The following exception types:
The following stream types:
The following smart pointer types:
The following interprocess communication types:
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 { template<typename VoidPointer> class message_queue_t; enum mqblock_types { blocking, timed, non_blocking }; typedef message_queue_t< offset_ptr< void > > 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; 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; } }
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; 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; } }
namespace boost { namespace interprocess { template<typename CharType, typename AllocationAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_mapped_file; 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; } }
namespace boost { namespace interprocess { template<typename CharType, typename AllocationAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_shared_memory; 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; } }
namespace boost { namespace interprocess { template<typename CharType, typename AllocationAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_windows_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; } }
namespace boost { namespace interprocess { template<typename CharType, typename AllocationAlgorithm, template< class IndexConfig > class IndexType> class basic_managed_xsi_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; } }
Describes mapped region class
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.
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, typename DifferenceType, typename OffsetType, std::size_t OffsetAlignment> class offset_ptr; 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 CharType, typename MemoryAlgorithm, template< class IndexConfig > class IndexType> class segment_manager; template<typename MemoryAlgorithm> class segment_manager_base; } }
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 to_raw_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 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> class 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 &, const std::nothrow_t &); } }
This header provides utilities to define a unique_ptr that plays nicely with managed segments.
namespace boost { namespace interprocess { template<typename T, typename ManagedMemory> struct managed_unique_ptr; 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> class 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_bufferstream; template<typename CharT, typename CharTraits> class basic_ibufferstream; template<typename CharT, typename CharTraits> class basic_obufferstream; 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_ivectorstream; template<typename CharVector, typename CharTraits> class basic_ovectorstream; template<typename CharVector, typename CharTraits> class basic_vectorbuf; template<typename CharVector, typename CharTraits> class basic_vectorstream; } }
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; } }
Describes process-shared variables interprocess_condition_any class
namespace boost { namespace interprocess { class interprocess_condition_any; } }
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 accept_ownership_type; struct defer_lock_type; struct try_to_lock_type; static const defer_lock_type defer_lock; static const try_to_lock_type try_to_lock; static const accept_ownership_type accept_ownership; } }
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; } }
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 some simple time-related utilities that can be used to call synchronization primitive and ipc methods that required waiting until the resource is signalled or a timeout expires.
These utilities are provided for those users that want to avoid dependence on std::chrono or boost::chrono or boost::date_time and just want to implement simple portable waits.
namespace boost { namespace interprocess { class usduration; class ustime; usduration usduration_from_seconds(boost::uint64_t); usduration usduration_from_milliseconds(boost::uint64_t); ustime ustime_delay_milliseconds(unsigned); } }
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; } }