![]() |
Home | Libraries | People | FAQ | More |
A B C D E F I L M N O P R S T U W X
accept_ownership_type
allocator
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
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
weak_ptr
windows_shared_memory
xsi_key
xsi_shared_memory
allocator_type
base_type
bufferstream
deleter_type
fixed_managed_shared_memory
key_less
key_type
managed_external_buffer
managed_heap_memory
managed_mapped_file
managed_shared_memory
mapped_type
multiallocation_chain
mutex_family
mutex_type
recursive_mutex_type
segment_manager
segment_manager_base
value_type
vector_type
void_allocator
void_pointer
wbufferstream
wfixed_managed_shared_memory
wmanaged_external_buffer
wmanaged_heap_memory
wmanaged_mapped_file
wmanaged_shared_memory
A B C D E F G I K L M N O P R S T U V W X
alignment
allocate
allocate_many
allocate_one
allocation_command
allocator
anonymous_shared_memory
APIs
atomic_func
data
deallocate
deallocate_many
deallocate_one
fail
find
flat_map_index
flush
ftok
lock
lock_exception
lock_sharable
lock_upgradable
name
named_condition
named_condition_any
named_mutex
named_recursive_mutex
named_semaphore
named_sharable_mutex
named_upgradable_mutex
p
pointer
POSIX
pred
release
remove
reserve
reset
segment
set_max_cached_nodes
shared_ptr
shrink_to_fit
size
sizeof
space
swap_vector
timed_lock
timed_lock_sharable
timed_lock_upgradable
timed_unlock_upgradable_and_lock
try_lock
try_lock_sharable
try_lock_shared_until
try_lock_until
try_lock_upgradable
try_unlock_sharable_and_lock
try_unlock_sharable_and_lock_upgradable
try_unlock_upgradable_and_lock
unlock
unlock_and_lock_sharable
unlock_and_lock_upgradable
unlock_sharable
unlock_upgradable
unlock_upgradable_and_lock
unlock_upgradable_and_lock_sharable
use_count
xsi_key
Describes adaptive_pool pooled shared memory STL compatible allocator
template<typename T, typename SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> class adaptive_pool; template<typename T, typename S, NodesPerBlock, F, OP> (adaptive_pool< , adaptive_pool< ); template<typename T, typename S, NodesPerBlock, F, OP> (adaptive_pool< , adaptive_pool< ); } }
Describes an allocator that allocates portions of fixed size memory buffer (shared memory, mapped file...)
template<typename T, typename SegmentManager> class allocator; template<typename T, typename SegmentManager> (allocator< , allocator< ); template<typename T, typename SegmentManager> (allocator< , allocator< ); } }
Describes cached_adaptive_pool pooled shared memory STL compatible allocator
template<typename T, typename SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> class cached_adaptive_pool; template<typename T, typename S, NodesPerBlock, F, OP> (cached_adaptive_pool< , cached_adaptive_pool< ); template<typename T, typename S, NodesPerBlock, F, OP> (cached_adaptive_pool< , cached_adaptive_pool< ); } }
Describes cached_cached_node_allocator pooled shared memory STL compatible allocator
template<typename T, typename SegmentManager, NodesPerBlock> class cached_node_allocator; template<typename T, typename S, NPC> (cached_node_allocator< , cached_node_allocator< ); template<typename T, typename S, NPC> (cached_node_allocator< , cached_node_allocator< ); } }
Describes node_allocator pooled shared memory STL compatible allocator
template<typename T, typename SegmentManager, NodesPerBlock> class node_allocator; template<typename T, typename S, NPC> (node_allocator< , node_allocator< ); template<typename T, typename S, NPC> (node_allocator< , node_allocator< ); } }
Describes private_adaptive_pool_base pooled shared memory STL compatible allocator
template<typename T, typename SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> class private_adaptive_pool; template<typename T, typename S, NodesPerBlock, F, OP> (private_adaptive_pool< , private_adaptive_pool< ); template<typename T, typename S, NodesPerBlock, F, OP> (private_adaptive_pool< , private_adaptive_pool< ); } }
Describes private_node_allocator_base pooled shared memory STL compatible allocator
template<typename T, typename SegmentManager, NodesPerBlock> class private_node_allocator; template<typename T, typename S, NodesPerBlock, F, OP> (private_node_allocator< , private_node_allocator< ); template<typename T, typename S, NodesPerBlock, F, OP> (private_node_allocator< , private_node_allocator< ); } }
Describes a function that creates anonymous shared memory that can be shared between forked processes
mapped_region (, = ); } }
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 create_only_t create_only; static open_only_t open_only; static open_read_only_t open_read_only; static open_or_create_t open_or_create; static open_copy_on_write_t open_copy_on_write; } }
Describes the error numbering of interprocess classes
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 ; } }
Describes exceptions thrown by interprocess classes
class bad_alloc; class interprocess_exception; class lock_exception; } }
Describes file_mapping and mapped region classes
class file_mapping; } }
Describes index adaptor of boost::map container, to use it as name/shared memory index
template<typename MapConfig> class flat_map_index; } }
Describes index adaptor of boost::intrusive::set container, to use it as name/shared memory index
template<typename MapConfig> class iset_index; } }
Describes index adaptor of boost::intrusive::unordered_set container, to use it as name/shared memory index
template<typename MapConfig> class iunordered_set_index; } }
Describes index adaptor of boost::map container, to use it as name/shared memory index
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.
template<typename MapConfig> class null_index; } }
Describes index adaptor of boost::unordered_map container, to use it as name/shared memory index
template<typename MapConfig> class unordered_map_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:
The following managed memory types:
boost::interprocess::managed_external_buffer
boost::interprocess::wmanaged_external_buffer
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_heap_memory
boost::interprocess::wmanaged_heap_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:
boost::interprocess::message_queue;
Describes an inter-process message queue. This class allows sending messages between processes and allows blocking, non-blocking and timed sending and receiving.
template<typename VoidPointer> class message_queue_t; enum mqblock_types { blocking, timed, non_blocking }; typedef message_queue_t< offset_ptr< ; } }
Describes a named user memory allocation user class.
template<typename CharType, typename AllocationAlgorithm, IndexType> class basic_managed_external_buffer; typedef basic_managed_external_buffer< rbtree_best_fit< null_mutex_family >,iset_index > ; typedef basic_managed_external_buffer< rbtree_best_fit< null_mutex_family >,iset_index > ; } }
Describes a named heap memory allocation user class.
template<typename CharType, typename AllocationAlgorithm, IndexType> class basic_managed_heap_memory; typedef basic_managed_heap_memory< rbtree_best_fit< null_mutex_family >,iset_index > ; typedef basic_managed_heap_memory< rbtree_best_fit< null_mutex_family >,iset_index > ; } }
template<typename CharType, typename AllocationAlgorithm, IndexType> class basic_managed_mapped_file; typedef basic_managed_mapped_file< rbtree_best_fit< mutex_family >,iset_index > ; typedef basic_managed_mapped_file< rbtree_best_fit< mutex_family >,iset_index > ; } }
template<typename CharType, typename AllocationAlgorithm, IndexType> class basic_managed_shared_memory; typedef basic_managed_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ; typedef basic_managed_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ; typedef basic_managed_shared_memory< rbtree_best_fit< mutex_family, iset_index > ; typedef basic_managed_shared_memory< rbtree_best_fit< mutex_family, iset_index > ; } }
template<typename CharType, typename AllocationAlgorithm, IndexType> class basic_managed_windows_shared_memory; typedef basic_managed_windows_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ; typedef basic_managed_windows_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ; } }
template<typename CharType, typename AllocationAlgorithm, IndexType> class basic_managed_xsi_shared_memory; typedef basic_managed_xsi_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ; typedef basic_managed_xsi_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ; } }
Describes mapped region class
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.
template<typename MutexFamily, typename VoidPointer, MemAlignment> class rbtree_best_fit; } }
Describes sequential fit algorithm used to allocate objects in shared memory.
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.
template<typename PointedType, typename DifferenceType, typename OffsetType, OffsetAlignment> class offset_ptr; template<typename E, typename T, typename W, typename X, typename Y, Z> (, offset_ptr< ); template<typename E, typename T, typename W, typename X, typename Y, Z> (, offset_ptr< ); // Simulation of static_cast between pointers. Never throws. template<typename T1, typename P1, typename O1, A1, typename T2, typename P2, typename O2, A2> boost::interprocess::offset_ptr< (boost::interprocess::offset_ptr< r); // Simulation of const_cast between pointers. Never throws. template<typename T1, typename P1, typename O1, A1, typename T2, typename P2, typename O2, A2> boost::interprocess::offset_ptr< (boost::interprocess::offset_ptr< r); // Simulation of dynamic_cast between pointers. Never throws. template<typename T1, typename P1, typename O1, A1, typename T2, typename P2, typename O2, A2> boost::interprocess::offset_ptr< (boost::interprocess::offset_ptr< r); // Simulation of reinterpret_cast between pointers. Never throws. template<typename T1, typename P1, typename O1, A1, typename T2, typename P2, typename O2, A2> boost::interprocess::offset_ptr< (boost::interprocess::offset_ptr< r); } }
Describes the object placed in a memory segment that provides named object allocation capabilities for single-segment and multi-segment allocations.
template<typename CharType, typename MemoryAlgorithm, IndexType> class segment_manager; template<typename MemoryAlgorithm> class segment_manager_base; } }
Describes a shared memory object management class.
class shared_memory_object; } }
Describes the functor to delete objects from the segment.
template<typename T, typename SegmentManager> class deleter; } }
Describes an utility to form a shared pointer from this
template<typename T, typename A, typename D> class enable_shared_from_this; } }
Describes an intrusive ownership pointer.
template<typename T, typename VoidPointer> class intrusive_ptr; template<typename T, typename U, typename VP> (intrusive_ptr< , intrusive_ptr< ); template<typename T, typename U, typename VP> (intrusive_ptr< , intrusive_ptr< ); template<typename T, typename VP> (intrusive_ptr< , intrusive_ptr< ); template<typename T, typename VP> (intrusive_ptr< , intrusive_ptr< ); template<typename T, typename VP> (intrusive_ptr< , intrusive_ptr< ); template<typename T, typename VP> (intrusive_ptr< , intrusive_ptr< ); template<typename T, typename VP> (intrusive_ptr< , intrusive_ptr< ); template<typename T, typename VP> (intrusive_ptr< , intrusive_ptr< ); template<typename E, typename T, typename Y, typename VP> ( os, intrusive_ptr< p); template<typename T, typename VP> boost::interprocess::intrusive_ptr< (intrusive_ptr< ); } }
Describes the smart pointer scoped_ptr
template<typename T, typename Deleter> class scoped_ptr; template<typename T, typename D> (scoped_ptr< , scoped_ptr< ); template<typename T, typename D> scoped_ptr< (scoped_ptr< ); } }
Describes the smart pointer shared_ptr
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> (shared_ptr< a, shared_ptr< b); template<typename T, typename VoidAllocator, typename Deleter, typename U, typename VoidAllocator2, typename Deleter2> (shared_ptr< a, shared_ptr< b); template<typename T, typename VoidAllocator, typename Deleter, typename U, typename VoidAllocator2, typename Deleter2> (shared_ptr< a, shared_ptr< b); template<typename T, typename VoidAllocator, typename Deleter> (shared_ptr< a, shared_ptr< b); template<typename T, typename VoidAllocator, typename Deleter, typename U> shared_ptr< (shared_ptr< r); template<typename T, typename VoidAllocator, typename Deleter, typename U> shared_ptr< (shared_ptr< r); template<typename T, typename VoidAllocator, typename Deleter, typename U> shared_ptr< (shared_ptr< r); template<typename T, typename VoidAllocator, typename Deleter> (shared_ptr< p); template<typename E, typename T, typename Y, typename VoidAllocator, typename Deleter> ( os, shared_ptr< p); template<typename T, typename ManagedMemory> managed_shared_ptr< (, ); template<typename T, typename ManagedMemory> managed_shared_ptr< (, , ); } }
This header provides utilities to define a unique_ptr that plays nicely with managed segments.
template<typename T, typename ManagedMemory> struct managed_unique_ptr; template<typename T, typename ManagedMemory> managed_unique_ptr< (, ); } }
Describes the smart pointer weak_ptr.
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> (weak_ptr< a, weak_ptr< b); template<typename T, typename A, typename D> (weak_ptr< a, weak_ptr< b); template<typename T, typename ManagedMemory> managed_weak_ptr< (, ); } }
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.
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< ; typedef basic_bufferstream< ; typedef basic_ibufferstream< ; typedef basic_obufferstream< ; typedef basic_bufferbuf< ; typedef basic_bufferstream< ; typedef basic_ibufferstream< ; typedef basic_obufferstream< ; } }
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.
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.
class file_lock; } }
Describes process-shared variables interprocess_condition class
class interprocess_condition; } }
Describes process-shared variables interprocess_condition_any class
class interprocess_condition_any; } }
Describes a mutex class that can be placed in memory shared by several processes.
class interprocess_mutex; } }
Describes interprocess_recursive_mutex and shared_recursive_try_mutex classes
class interprocess_recursive_mutex; } }
Describes a interprocess_semaphore class for inter-process synchronization
class interprocess_semaphore; } }
Describes interprocess_sharable_mutex class
class interprocess_sharable_mutex; } }
Describes interprocess_upgradable_mutex class
class interprocess_upgradable_mutex; } }
Describes the lock options with associated with interprocess_mutex lock constructors.
struct accept_ownership_type; struct defer_lock_type; struct try_to_lock_type; static defer_lock_type defer_lock; static try_to_lock_type try_to_lock; static accept_ownership_type accept_ownership; } }
Describes a shared interprocess_mutex family fit algorithm used to allocate objects in shared memory.
struct mutex_family; struct null_mutex_family; } }
Describes a named condition class for inter-process synchronization
class named_condition; } }
Describes a named condition class for inter-process synchronization
class named_condition_any; } }
Describes a named mutex class for inter-process synchronization
class named_mutex; } }
Describes a named named_recursive_mutex class for inter-process synchronization
class named_recursive_mutex; } }
Describes a named semaphore class for inter-process synchronization
class named_semaphore; } }
Describes a named sharable mutex class for inter-process synchronization
class named_sharable_mutex; } }
Describes a named upgradable mutex class for inter-process synchronization
class named_upgradable_mutex; } }
Describes the scoped_lock class.
template<typename Mutex> class scoped_lock; } }
Describes the upgradable_lock class that serves to acquire the upgradable lock of a mutex.
template<typename SharableMutex> class sharable_lock; } }
Describes the upgradable_lock class that serves to acquire the upgradable lock of a mutex.
template<typename UpgradableMutex> class upgradable_lock; } }
Describes a class representing a native windows shared memory.
class windows_shared_memory; } }
Describes a class representing a xsi key type.
class xsi_key; } }
Describes a class representing a native xsi shared memory.
class xsi_shared_memory; } }