| Home | Libraries | People | FAQ | More

## Indexes and Reference

### Indexes

#### Class Index

A B C D E F I L M N O P R S T U W X

A

  - accept_ownership_type

    - Struct accept_ownership_type

  - allocator

    - Class template allocator

    - Class template segment_manager

    - Struct template allocator

  - allocator_holder

    - Class template iunordered_set_index

B

  - bad_alloc

    - Class bad_alloc

  - basic_bufferbuf

    - Class template basic_bufferbuf

  - basic_managed_external_buffer

    - Class template basic_managed_external_buffer

  - basic_managed_heap_memory

    - Class template basic_managed_heap_memory

  - basic_managed_shared_memory

    - Class template basic_managed_shared_memory

  - basic_managed_windows_shared_memory

    - Class template basic_managed_windows_shared_memory

  - basic_managed_xsi_shared_memory

    - Class template basic_managed_xsi_shared_memory

  - basic_vectorbuf

    - Class template basic_vectorbuf

C

  - create_only_t

    - Struct create_only_t

D

  - defer_lock_type

    - Struct defer_lock_type

  - deleter

    - Class template deleter

    - Class template segment_manager

    - Struct template deleter

E

  - enable_shared_from_this

    - Class template enable_shared_from_this

F

  - file_lock

    - Class file_lock

  - file_mapping

    - Class file_mapping

  - flat_map_index_aux

    - Building custom indexes

    - Class template flat_map_index

I

  - interprocess_condition

    - Class interprocess_condition

  - interprocess_condition_any

    - Class interprocess_condition_any

  - interprocess_exception

    - Class bad_alloc

    - Class interprocess_exception

    - Class lock_exception

  - interprocess_mutex

    - Class interprocess_mutex

  - interprocess_recursive_mutex

    - Class interprocess_recursive_mutex

  - interprocess_semaphore

    - Class interprocess_semaphore

  - interprocess_sharable_mutex

    - Class interprocess_sharable_mutex

  - interprocess_upgradable_mutex

    - Class interprocess_upgradable_mutex

  - intrusive_ptr

    - Class template intrusive_ptr

  - iset_index_aux

    - Class template iset_index

  - iunordered_set_index_aux

    - Class template iunordered_set_index

L

  - lock_exception

    - Class lock_exception

M

  - managed_shared_ptr

    - Struct template managed_shared_ptr

  - managed_unique_ptr

    - Struct template managed_unique_ptr

  - managed_weak_ptr

    - Struct template managed_weak_ptr

  - mapped_region

    - Class mapped_region

  - message_queue_t

    - Class template message_queue_t

  - mutex_family

    - Struct mutex_family

    - Writing a new shared memory allocation algorithm

N

  - named_condition

    - Class named_condition

  - named_condition_any

    - Class named_condition_any

  - named_mutex

    - Class named_mutex

  - named_recursive_mutex

    - Class named_recursive_mutex

  - named_semaphore

    - Class named_semaphore

  - named_sharable_mutex

    - Class named_sharable_mutex

  - named_upgradable_mutex

    - Class named_upgradable_mutex

  - null_index

    - Class template null_index

  - null_mutex

    - Class null_mutex

  - null_mutex_family

    - Struct null_mutex_family

O

  - offset_ptr

    - Class template offset_ptr

  - open_copy_on_write_t

    - Struct open_copy_on_write_t

  - open_only_t

    - Struct open_only_t

  - open_or_create_t

    - Struct open_or_create_t

  - open_read_only_t

    - Struct open_read_only_t

  - open_read_private_t

    - Struct open_read_private_t

P

  - permissions

    - Class permissions

R

  - rbtree_best_fit

    - Class template rbtree_best_fit

  - rebind

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template offset_ptr

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Struct template rebind

S

  - scoped_lock

    - Class template scoped_lock

  - scoped_ptr

    - Class template scoped_ptr

  - segment_manager

    - Class template segment_manager

    - Intrusive pointer

    - Scoped pointer

  - segment_manager_base

    - Building custom indexes

    - Class template segment_manager

    - Class template segment_manager_base

  - sharable_lock

    - Class template sharable_lock

  - shared_memory_object

    - Class shared_memory_object

  - shared_ptr

    - Class template shared_ptr

  - simple_seq_fit

    - Class template simple_seq_fit

T

  - try_to_lock_type

    - Struct try_to_lock_type

U

  - unordered_map_index_aux

    - Class template unordered_map_index

  - upgradable_lock

    - Class template upgradable_lock

W

  - windows_shared_memory

    - Class windows_shared_memory

X

  - xsi_key

    - Class xsi_key

  - xsi_shared_memory

    - Class xsi_shared_memory

#### Typedef Index

A B C D E F I K M N O P R S T U V W

A

  - allocator_type

    - Building custom indexes

B

  - base_t

    - Class template basic_bufferbuf

  - base_type

    - Building custom indexes

  - bucket_ptr

    - Class template iunordered_set_index

  - bucket_traits

    - Class template iunordered_set_index

  - bucket_type

    - Class template iunordered_set_index

  - bufferbuf

    - Header < boost/interprocess/streams/bufferstream.hpp >

  - bufferstream

    - Formatting directly in your character buffer: bufferstream

    - Header < boost/interprocess/streams/bufferstream.hpp >

C

  - char_ptr

    - Class template message_queue_t

  - char_type

    - Building custom indexes

    - Class template basic_bufferbuf

    - Class template basic_bufferstream

    - Class template basic_ibufferstream

    - Class template basic_ivectorstream

    - Class template basic_obufferstream

    - Class template basic_ovectorstream

    - Class template basic_vectorbuf

    - Class template basic_vectorstream

    - Class template segment_manager

    - Formatting directly in your character buffer: bufferstream

    - Formatting directly in your character vector: vectorstream

  - const_allocator_pointer

    - Class template shared_ptr

  - const_deleter_pointer

    - Class template shared_ptr

  - const_iterator

    - Class template iset_index

    - Class template iunordered_set_index

    - Class template null_index

  - const_named_iterator

    - Class template segment_manager

  - const_pointer

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

  - const_reference

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template shared_ptr

  - const_unique_iterator

    - Class template segment_manager

D

  - deleter

    - Struct template managed_shared_ptr

  - deleter_type

    - Class template scoped_ptr

    - Shared pointer and weak pointer

  - difference_type

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template message_queue_t

    - Class template node_allocator

    - Class template offset_ptr

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template rbtree_best_fit

    - Class template segment_manager

E

  - element_type

    - Class template intrusive_ptr

    - Class template offset_ptr

    - Class template scoped_ptr

    - Class template shared_ptr

F

  - fixed_managed_shared_memory

    - Common Managed Shared Memory Classes

    - Header < boost/interprocess/managed_shared_memory.hpp >

    - Type definition fixed_managed_shared_memory

I

  - ibufferstream

    - Header < boost/interprocess/streams/bufferstream.hpp >

  - index_aux

    - Building custom indexes

  - index_t

    - Building custom indexes

  - insert_commit_data

    - Class template iset_index

    - Class template iunordered_set_index

  - int_type

    - Class template basic_bufferbuf

    - Class template basic_bufferstream

    - Class template basic_ibufferstream

    - Class template basic_ivectorstream

    - Class template basic_obufferstream

    - Class template basic_ovectorstream

    - Class template basic_vectorbuf

    - Class template basic_vectorstream

    - Formatting directly in your character buffer: bufferstream

    - Formatting directly in your character vector: vectorstream

  - iterator

    - Class template iset_index

    - Class template iunordered_set_index

    - Class template null_index

  - iterator_category

    - Class template offset_ptr

K

  - key_less

    - Building custom indexes

  - key_type

    - Building custom indexes

M

  - managed_external_buffer

    - Header < boost/interprocess/managed_external_buffer.hpp >

    - Managed External Buffer: Constructing all Boost.Interprocess objects in a user provided buffer

    - Type definition managed_external_buffer

  - managed_heap_memory

    - Header < boost/interprocess/managed_heap_memory.hpp >

    - Managed Heap Memory: Boost.Interprocess machinery in heap memory

    - Type definition managed_heap_memory

  - managed_mapped_file

    - Common Managed Mapped Files

    - Header < boost/interprocess/managed_mapped_file.hpp >

    - Type definition managed_mapped_file

  - managed_shared_memory

    - Common Managed Shared Memory Classes

    - Header < boost/interprocess/managed_shared_memory.hpp >

    - Type definition managed_shared_memory

  - managed_windows_shared_memory

    - Header < boost/interprocess/managed_windows_shared_memory.hpp >

    - Type definition managed_windows_shared_memory

  - managed_xsi_shared_memory

    - Header < boost/interprocess/managed_xsi_shared_memory.hpp >

    - Type definition managed_xsi_shared_memory

  - mapped_type

    - Building custom indexes

  - memory_algorithm

    - Class template segment_manager

    - Class template segment_manager_base

  - message_queue

    - Header < boost/interprocess/ipc/message_queue.hpp >

    - Type definition message_queue

  - multiallocation_chain

    - Class template rbtree_best_fit

    - Multiple allocation functions

  - mutex_family

    - Class template rbtree_best_fit

    - Class template segment_manager

    - Class template segment_manager_base

    - The memory algorithm

    - Writing a new shared memory allocation algorithm

  - mutex_type

    - Class template scoped_lock

    - Class template sharable_lock

    - Class template upgradable_lock

    - Struct mutex_family

    - Struct null_mutex_family

    - Writing a new shared memory allocation algorithm

N

  - native_error_t

    - Header < boost/interprocess/errors.hpp >

O

  - obufferstream

    - Header < boost/interprocess/streams/bufferstream.hpp >

  - offset_type

    - Class template offset_ptr

  - off_type

    - Class template basic_bufferbuf

    - Class template basic_bufferstream

    - Class template basic_ibufferstream

    - Class template basic_ivectorstream

    - Class template basic_obufferstream

    - Class template basic_ovectorstream

    - Class template basic_vectorbuf

    - Class template basic_vectorstream

    - Formatting directly in your character buffer: bufferstream

    - Formatting directly in your character vector: vectorstream

  - other

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template offset_ptr

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Struct template rebind

P

  - pointer

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template deleter

    - Class template intrusive_ptr

    - Class template node_allocator

    - Class template offset_ptr

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template scoped_ptr

    - Class template shared_ptr

    - Scoped pointer

  - pos_type

    - Class template basic_bufferbuf

    - Class template basic_bufferstream

    - Class template basic_ibufferstream

    - Class template basic_ivectorstream

    - Class template basic_obufferstream

    - Class template basic_ovectorstream

    - Class template basic_vectorbuf

    - Class template basic_vectorstream

    - Formatting directly in your character buffer: bufferstream

    - Formatting directly in your character vector: vectorstream

R

  - recursive_mutex_type

    - Struct mutex_family

    - Struct null_mutex_family

    - Writing a new shared memory allocation algorithm

  - reference

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template offset_ptr

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template shared_ptr

S

  - segment_manager

    - Building custom indexes

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Intrusive pointer

    - Scoped pointer

  - segment_manager_base

    - Building custom indexes

  - segment_manager_base_type

    - Class template segment_manager

    - Class template segment_manager_base

  - size_type

    - Class template adaptive_pool

    - Class template allocator

    - Class template basic_managed_external_buffer

    - Class template basic_managed_heap_memory

    - Class template basic_managed_mapped_file

    - Class template basic_managed_windows_shared_memory

    - Class template basic_managed_xsi_shared_memory

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template iunordered_set_index

    - Class template message_queue_t

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template rbtree_best_fit

    - Class template segment_manager

    - Class template simple_seq_fit

T

  - traits_type

    - Class template basic_bufferbuf

    - Class template basic_bufferstream

    - Class template basic_ibufferstream

    - Class template basic_ivectorstream

    - Class template basic_obufferstream

    - Class template basic_ovectorstream

    - Class template basic_vectorbuf

    - Class template basic_vectorstream

    - Formatting directly in your character buffer: bufferstream

    - Formatting directly in your character vector: vectorstream

  - type

    - Class template segment_manager

    - Struct template allocator

    - Struct template deleter

    - Struct template managed_shared_ptr

    - Struct template managed_unique_ptr

    - Struct template managed_weak_ptr

U

  - unspecified_bool_type

    - Class template scoped_ptr

V

  - value_type

    - Building custom indexes

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template iset_index

    - Class template iunordered_set_index

    - Class template node_allocator

    - Class template offset_ptr

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template shared_ptr

  - vector_type

    - Class template basic_ivectorstream

    - Class template basic_ovectorstream

    - Class template basic_vectorbuf

    - Class template basic_vectorstream

    - Formatting directly in your character vector: vectorstream

  - version

    - Class template allocator

  - void_allocator

    - Containers of containers

    - Struct template managed_shared_ptr

  - void_pointer

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template message_queue_t

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template rbtree_best_fit

    - Class template segment_manager

    - Class template segment_manager_base

    - The memory algorithm

    - Writing a new shared memory allocation algorithm

W

  - wbufferbuf

    - Header < boost/interprocess/streams/bufferstream.hpp >

  - wbufferstream

    - Formatting directly in your character buffer: bufferstream

    - Header < boost/interprocess/streams/bufferstream.hpp >

  - wfixed_managed_shared_memory

    - Common Managed Shared Memory Classes

    - Header < boost/interprocess/managed_shared_memory.hpp >

    - Type definition wfixed_managed_shared_memory

  - wibufferstream

    - Header < boost/interprocess/streams/bufferstream.hpp >

  - wmanaged_external_buffer

    - Header < boost/interprocess/managed_external_buffer.hpp >

    - Managed External Buffer: Constructing all Boost.Interprocess objects in a user provided buffer

    - Type definition wmanaged_external_buffer

  - wmanaged_heap_memory

    - Header < boost/interprocess/managed_heap_memory.hpp >

    - Managed Heap Memory: Boost.Interprocess machinery in heap memory

    - Type definition wmanaged_heap_memory

  - wmanaged_mapped_file

    - Common Managed Mapped Files

    - Header < boost/interprocess/managed_mapped_file.hpp >

    - Type definition wmanaged_mapped_file

  - wmanaged_shared_memory

    - Common Managed Shared Memory Classes

    - Header < boost/interprocess/managed_shared_memory.hpp >

    - Type definition wmanaged_shared_memory

  - wmanaged_windows_shared_memory

    - Header < boost/interprocess/managed_windows_shared_memory.hpp >

    - Type definition wmanaged_windows_shared_memory

  - wmanaged_xsi_shared_memory

    - Header < boost/interprocess/managed_xsi_shared_memory.hpp >

    - Type definition wmanaged_xsi_shared_memory

  - wobufferstream

    - Header < boost/interprocess/streams/bufferstream.hpp >

#### Function Index

A B C D E F G I L M N O P R S T U W Z

A

  - adaptive_pool

    - Class template adaptive_pool

  - advise

    - Class mapped_region

  - allocate

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template rbtree_best_fit

    - Class template segment_manager_base

    - Multiple allocation functions

    - Performance of raw memory allocations

    - Synchronization guarantees

    - The segment manager

    - Writing a new shared memory allocation algorithm

  - allocate_aligned

    - Class template rbtree_best_fit

    - Class template segment_manager_base

  - allocate_individual

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

  - allocate_many

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Multiple allocation functions

  - allocate_one

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

  - allocation_command

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template rbtree_best_fit

    - Expand in place memory allocation

  - all_memory_deallocated

    - Class template rbtree_best_fit

    - Class template segment_manager_base

  - atomic_func

    - Class template segment_manager

    - Executing an object function atomically

B

  - bad_alloc

    - Class bad_alloc

  - basic_managed_external_buffer

    - Class template basic_managed_external_buffer

  - basic_managed_heap_memory

    - Class template basic_managed_heap_memory

  - basic_managed_shared_memory

    - Class template basic_managed_shared_memory

  - basic_managed_windows_shared_memory

    - Class template basic_managed_windows_shared_memory

  - basic_managed_xsi_shared_memory

    - Class template basic_managed_xsi_shared_memory

  - begin

    - Class template null_index

  - buffer

    - Anonymous condition example

    - Building custom indexes

    - Class template basic_bufferbuf

    - Class template basic_bufferstream

    - Class template basic_ibufferstream

    - Class template basic_obufferstream

    - Formatting directly in your character buffer: bufferstream

    - Header < boost/interprocess/allocators/allocator.hpp >

    - Introduction

C

  - cached_adaptive_pool

    - Class template cached_adaptive_pool

  - cached_node_allocator

    - Class template cached_node_allocator

  - check_sanity

    - Class template rbtree_best_fit

    - Class template segment_manager_base

  - clear

    - Class template basic_ivectorstream

    - Class template basic_vectorbuf

    - Class template basic_vectorstream

  - construct

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template segment_manager

  - construct_it

    - Class template segment_manager

D

  - data

    - What's A Message Queue?

  - deallocate

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template rbtree_best_fit

    - Class template segment_manager_base

    - Performance of raw memory allocations

    - Writing a new shared memory allocation algorithm

  - deallocate_free_blocks

    - Class template adaptive_pool

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

  - deallocate_individual

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

  - deallocate_many

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Multiple allocation functions

  - deallocate_one

    - Class template adaptive_pool

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

  - destroy

    - Class template allocator

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template segment_manager

  - destroy_ptr

    - Class template segment_manager

E

  - end

    - Class template null_index

F

  - file_mapping

    - Class file_mapping

  - find

    - Class template iset_index

    - Class template iunordered_set_index

    - Class template segment_manager

    - Performance of named allocations

  - find_or_construct

    - Class template segment_manager

  - find_or_construct_it

    - Class template segment_manager

  - flush

    - Be Careful With Iostream Writing

    - Class mapped_region

    - Class template basic_managed_mapped_file

  - for

    - Formatting directly in your character buffer: bufferstream

    - Formatting directly in your character vector: vectorstream

G

  - get

    - Class template intrusive_ptr

    - Class template offset_ptr

    - Class template scoped_ptr

    - Class template shared_ptr

  - get_allocator

    - Class template segment_manager

  - get_deleter

    - Class template segment_manager

  - get_instance_length

    - Class template segment_manager

  - get_instance_name

    - Class template segment_manager

  - get_instance_type

    - Class template segment_manager

  - get_min_size

    - Class template rbtree_best_fit

    - Class template segment_manager

    - Class template segment_manager_base

    - Writing a new shared memory allocation algorithm

  - get_num_named_objects

    - Class template segment_manager

  - get_num_unique_objects

    - Class template segment_manager

  - get_page_size

    - Class mapped_region

  - grow

    - Class template basic_managed_external_buffer

    - Class template basic_managed_heap_memory

    - Class template basic_managed_mapped_file

    - Class template basic_managed_shared_memory

    - Class template rbtree_best_fit

    - Class template segment_manager_base

    - Managed Heap Memory: Boost.Interprocess machinery in heap memory

    - Writing a new shared memory allocation algorithm

I

  - if

    - Creating named shared memory objects

    - Creating vectors in shared memory

    - Example: Serializing a database through the message queue

    - Intrusive pointer

    - Managed External Buffer: Constructing all Boost.Interprocess objects in a user provided buffer

    - Multiple allocation functions

    - Opening managed shared memory and mapped files with Copy On Write or Read Only modes

    - Scoped lock

    - Scoped pointer

    - Sharable Lock And Upgradable Lock

    - Using shared memory as a pool of unnamed memory blocks

  - insert_commit

    - Class template iunordered_set_index

  - interprocess_condition

    - Class interprocess_condition

  - interprocess_condition_any

    - Class interprocess_condition_any

  - interprocess_exception

    - Class interprocess_exception

  - interprocess_mutex

    - Class interprocess_mutex

  - interprocess_recursive_mutex

    - Class interprocess_recursive_mutex

  - interprocess_semaphore

    - Class interprocess_semaphore

  - interprocess_sharable_mutex

    - Class interprocess_sharable_mutex

  - interprocess_upgradable_mutex

    - Class interprocess_upgradable_mutex

  - intrusive_ptr_add_ref

    - Class template intrusive_ptr

    - Intrusive pointer

  - intrusive_ptr_release

    - Class template intrusive_ptr

    - Intrusive pointer

L

  - lock

    - Anonymous condition example

    - Anonymous mutex example

    - Class file_lock

    - Class interprocess_mutex

    - Class interprocess_recursive_mutex

    - Class interprocess_sharable_mutex

    - Class interprocess_upgradable_mutex

    - Class named_mutex

    - Class named_recursive_mutex

    - Class named_sharable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template scoped_lock

    - Class template sharable_lock

    - Class template upgradable_lock

    - Exclusive Locking (Sharable & Upgradable Mutexes)

    - File Locking Operations

    - Mutex Operations

    - Named mutex example

    - Scoped lock

    - Sharable Lock And Upgradable Lock

    - What's a Sharable and an Upgradable Mutex?

  - lock_exception

    - Class lock_exception

    - Class template scoped_lock

    - Class template sharable_lock

    - Class template upgradable_lock

  - lock_sharable

    - Class file_lock

    - Class interprocess_sharable_mutex

    - Class interprocess_upgradable_mutex

    - Class named_sharable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template sharable_lock

    - File Locking Operations

    - Sharable Lock And Upgradable Lock

    - Sharable Locking (Sharable & Upgradable Mutexes)

  - lock_upgradable

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template upgradable_lock

    - Sharable Lock And Upgradable Lock

    - Upgradable Locking (Upgradable Mutex only)

M

  - make_managed_shared_ptr

    - Function template make_managed_shared_ptr

    - Header < boost/interprocess/smart_ptr/shared_ptr.hpp >

  - make_managed_unique_ptr

    - Function template make_managed_unique_ptr

    - Header < boost/interprocess/smart_ptr/unique_ptr.hpp >

  - make_managed_weak_ptr

    - Function template make_managed_weak_ptr

    - Header < boost/interprocess/smart_ptr/weak_ptr.hpp >

  - mapped_region

    - Boost 1.54 Release

    - Class mapped_region

N

  - name

    - Boost unordered containers

    - Building custom indexes

    - Creating maps in shared memory

  - named_condition

    - Class named_condition

  - named_condition_any

    - Class named_condition_any

  - named_mutex

    - Class named_mutex

  - named_recursive_mutex

    - Class named_recursive_mutex

  - named_semaphore

    - Class named_semaphore

  - named_sharable_mutex

    - Class named_sharable_mutex

  - named_upgradable_mutex

    - Class named_upgradable_mutex

  - node_allocator

    - Class template node_allocator

  - notify_all

    - Class interprocess_condition

    - Class interprocess_condition_any

    - Class named_condition

    - Class named_condition_any

  - notify_one

    - Class interprocess_condition

    - Class interprocess_condition_any

    - Class named_condition

    - Class named_condition_any

  - null_index

    - Class template null_index

O

  - offset_ptr

    - Class template offset_ptr

P

  - pointer_to

    - Class template offset_ptr

  - post

    - Class interprocess_semaphore

    - Class named_semaphore

  - pred

    - Class interprocess_condition

    - Class interprocess_condition_any

    - Class named_condition

    - Class named_condition_any

  - private_adaptive_pool

    - Class template private_adaptive_pool

  - private_node_allocator

    - Class template private_node_allocator

R

  - raw_allocation_command

    - Class template rbtree_best_fit

  - rbtree_best_fit

    - Class template rbtree_best_fit

  - receive

    - Class template message_queue_t

  - release

    - Class template scoped_lock

    - Class template scoped_ptr

    - Class template sharable_lock

    - Class template upgradable_lock

    - Scoped pointer

  - remove

    - Class file_mapping

    - Class named_condition

    - Class named_condition_any

    - Class named_mutex

    - Class named_recursive_mutex

    - Class named_semaphore

    - Class named_sharable_mutex

    - Class named_upgradable_mutex

    - Class shared_memory_object

    - Class template basic_managed_mapped_file

    - Class template basic_managed_shared_memory

    - Class template basic_managed_xsi_shared_memory

    - Class template message_queue_t

    - Class xsi_shared_memory

    - Constructing Managed Mapped Files

    - Removing shared memory

  - reserve

    - Building custom indexes

    - Class template basic_ivectorstream

    - Class template basic_ovectorstream

    - Class template basic_vectorbuf

    - Class template basic_vectorstream

    - Class template flat_map_index

    - Class template iset_index

    - Class template iunordered_set_index

    - Class template map_index

    - Class template unordered_map_index

    - Formatting directly in your character vector: vectorstream

    - Performance of raw memory allocations

  - reserve_named_objects

    - Class template segment_manager

  - reserve_unique_objects

    - Class template segment_manager

  - reset

    - Class template scoped_ptr

    - Class template shared_ptr

S

  - segment_manager

    - Class template segment_manager

  - send

    - Class template message_queue_t

  - set_default

    - Class permissions

  - set_max_cached_nodes

    - cached_adaptive_pool: Avoiding synchronization overhead

    - cached_node_allocator: caching nodes to avoid overhead

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

  - set_permissions

    - Class permissions

  - set_unrestricted

    - Class permissions

  - sharable_lock

    - Class template sharable_lock

  - shrink_by

    - Class mapped_region

  - shrink_to_fit

    - Building custom indexes

    - Class template basic_managed_mapped_file

    - Class template basic_managed_shared_memory

    - Class template flat_map_index

    - Class template iset_index

    - Class template iunordered_set_index

    - Class template map_index

    - Class template rbtree_best_fit

    - Class template segment_manager_base

    - Class template unordered_map_index

  - shrink_to_fit_indexes

    - Class template segment_manager

  - swap

    - Class file_lock

    - Class file_mapping

    - Class mapped_region

    - Class shared_memory_object

    - Class template adaptive_pool

    - Class template allocator

    - Class template basic_managed_external_buffer

    - Class template basic_managed_heap_memory

    - Class template basic_managed_mapped_file

    - Class template basic_managed_shared_memory

    - Class template basic_managed_windows_shared_memory

    - Class template basic_managed_xsi_shared_memory

    - Class template cached_adaptive_pool

    - Class template cached_node_allocator

    - Class template intrusive_ptr

    - Class template node_allocator

    - Class template private_adaptive_pool

    - Class template private_node_allocator

    - Class template scoped_lock

    - Class template scoped_ptr

    - Class template sharable_lock

    - Class template shared_ptr

    - Class template upgradable_lock

    - Class windows_shared_memory

    - Class xsi_shared_memory

    - Function template swap

    - Header < boost/interprocess/smart_ptr/intrusive_ptr.hpp >

    - Header < boost/interprocess/smart_ptr/scoped_ptr.hpp >

    - Header < boost/interprocess/smart_ptr/shared_ptr.hpp >

    - Header < boost/interprocess/smart_ptr/weak_ptr.hpp >

  - swap_vector

    - Class template basic_ivectorstream

    - Class template basic_ovectorstream

    - Class template basic_vectorbuf

    - Class template basic_vectorstream

    - Formatting directly in your character vector: vectorstream

T

  - timed_lock

    - Class file_lock

    - Class interprocess_mutex

    - Class interprocess_recursive_mutex

    - Class interprocess_sharable_mutex

    - Class interprocess_upgradable_mutex

    - Class named_mutex

    - Class named_recursive_mutex

    - Class named_sharable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template scoped_lock

    - Class template sharable_lock

    - Class template upgradable_lock

    - Exclusive Locking (Sharable & Upgradable Mutexes)

    - File Locking Operations

    - Mutex Operations

  - timed_lock_sharable

    - Class file_lock

    - Class interprocess_sharable_mutex

    - Class interprocess_upgradable_mutex

    - Class named_sharable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template sharable_lock

    - File Locking Operations

    - Sharable Lock And Upgradable Lock

    - Sharable Locking (Sharable & Upgradable Mutexes)

  - timed_lock_upgradable

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template upgradable_lock

    - Sharable Lock And Upgradable Lock

    - Upgradable Locking (Upgradable Mutex only)

  - timed_receive

    - Class template message_queue_t

  - timed_send

    - Class template message_queue_t

  - timed_unlock_upgradable_and_lock

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template scoped_lock

    - Promotions (Upgradable Mutex only)

    - Transfers To Scoped Lock

  - timed_wait

    - Class interprocess_condition

    - Class interprocess_condition_any

    - Class interprocess_semaphore

    - Class named_condition

    - Class named_condition_any

    - Class named_semaphore

  - to_raw_pointer

    - Function template to_raw_pointer

    - Header < boost/interprocess/smart_ptr/intrusive_ptr.hpp >

    - Header < boost/interprocess/smart_ptr/scoped_ptr.hpp >

    - Header < boost/interprocess/smart_ptr/shared_ptr.hpp >

  - truncate

    - Class shared_memory_object

  - try_atomic_func

    - Class template segment_manager

  - try_lock

    - Boost 1.56 Release

    - Class file_lock

    - Class interprocess_mutex

    - Class interprocess_recursive_mutex

    - Class interprocess_sharable_mutex

    - Class interprocess_upgradable_mutex

    - Class named_mutex

    - Class named_recursive_mutex

    - Class named_sharable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template scoped_lock

    - Class template sharable_lock

    - Class template upgradable_lock

    - Exclusive Locking (Sharable & Upgradable Mutexes)

    - File Locking Operations

    - Global try_to_lock

    - Mutex Operations

  - try_lock_sharable

    - Class file_lock

    - Class interprocess_sharable_mutex

    - Class interprocess_upgradable_mutex

    - Class named_sharable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template sharable_lock

    - File Locking Operations

    - Sharable Lock And Upgradable Lock

    - Sharable Locking (Sharable & Upgradable Mutexes)

  - try_lock_upgradable

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template upgradable_lock

    - Sharable Lock And Upgradable Lock

    - Upgradable Locking (Upgradable Mutex only)

  - try_receive

    - Class template message_queue_t

  - try_send

    - Class template message_queue_t

  - try_unlock_sharable_and_lock

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template scoped_lock

    - Promotions (Upgradable Mutex only)

    - Transfers To Scoped Lock

  - try_unlock_sharable_and_lock_upgradable

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template upgradable_lock

    - Promotions (Upgradable Mutex only)

    - Transfers To Upgradable Lock

  - try_unlock_upgradable_and_lock

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template scoped_lock

    - Promotions (Upgradable Mutex only)

    - Transfers To Scoped Lock

  - try_wait

    - Class interprocess_semaphore

    - Class named_semaphore

U

  - unlock

    - Class file_lock

    - Class interprocess_mutex

    - Class interprocess_recursive_mutex

    - Class interprocess_sharable_mutex

    - Class interprocess_upgradable_mutex

    - Class named_mutex

    - Class named_recursive_mutex

    - Class named_sharable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template scoped_lock

    - Class template sharable_lock

    - Class template upgradable_lock

    - Exclusive Locking (Sharable & Upgradable Mutexes)

    - File Locking Operations

    - Mutex Operations

    - Scoped lock

    - Simple Lock Transfer

  - unlock_and_lock_sharable

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template sharable_lock

    - Demotions (Upgradable Mutex only)

    - Lock Transfers Through Move Semantics

    - Scoped Lock and Sharable Lock With File Locking

    - Transferring Unlocked Locks

    - Transfers To Sharable Lock

  - unlock_and_lock_upgradable

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Demotions (Upgradable Mutex only)

    - Transfers To Upgradable Lock

  - unlock_sharable

    - Class file_lock

    - Class interprocess_sharable_mutex

    - Class interprocess_upgradable_mutex

    - Class named_sharable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template sharable_lock

    - File Locking Operations

    - Sharable Lock And Upgradable Lock

    - Sharable Locking (Sharable & Upgradable Mutexes)

    - Simple Lock Transfer

  - unlock_upgradable

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template upgradable_lock

    - Sharable Lock And Upgradable Lock

    - Upgradable Locking (Upgradable Mutex only)

  - unlock_upgradable_and_lock

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template scoped_lock

    - Promotions (Upgradable Mutex only)

    - Transfers To Scoped Lock

  - unlock_upgradable_and_lock_sharable

    - Class interprocess_upgradable_mutex

    - Class named_upgradable_mutex

    - Class null_mutex

    - Class template sharable_lock

    - Demotions (Upgradable Mutex only)

    - Transfers To Sharable Lock

  - upgradable_lock

    - Class template upgradable_lock

W

  - wait

    - Class interprocess_condition

    - Class interprocess_condition_any

    - Class interprocess_semaphore

    - Class named_condition

    - Class named_condition_any

    - Class named_semaphore

  - while

    - Anonymous mutex example

    - Direct iostream formatting: vectorstream and bufferstream

    - Example: Serializing a database through the message queue

    - Multiple allocation functions

Z

  - zero_free_memory

    - Class template rbtree_best_fit

    - Class template segment_manager_base

### Boost.Interprocess Header Reference

#### Header <boost/interprocess/allocators/adaptive_pool.hpp>

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 > &);
      }
    }

#### Header <boost/interprocess/allocators/allocator.hpp>

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 > &);
      }
    }

#### Header <boost/interprocess/allocators/cached_adaptive_pool.hpp>

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 > &);
      }
    }

#### Header <boost/interprocess/allocators/cached_node_allocator.hpp>

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 > &);
      }
    }

#### Header <boost/interprocess/allocators/node_allocator.hpp>

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 > &);
      }
    }

#### Header <boost/interprocess/allocators/private_adaptive_pool.hpp>

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 > &);
      }
    }

#### Header <boost/interprocess/allocators/private_node_allocator.hpp>

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 > &);
      }
    }

#### Header <boost/interprocess/anonymous_shared_memory.hpp>

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);
      }
    }

#### Header <boost/interprocess/containers/allocation_type.hpp>

#### Header <boost/interprocess/containers/deque.hpp>

#### Header <boost/interprocess/containers/flat_map.hpp>

#### Header <boost/interprocess/containers/flat_set.hpp>

#### Header <boost/interprocess/containers/list.hpp>

#### Header <boost/interprocess/containers/map.hpp>

#### Header <boost/interprocess/containers/pair.hpp>

#### Header <boost/interprocess/containers/set.hpp>

#### Header <boost/interprocess/containers/slist.hpp>

#### Header <boost/interprocess/containers/stable_vector.hpp>

#### Header <boost/interprocess/containers/string.hpp>

#### Header <boost/interprocess/containers/vector.hpp>

#### Header <boost/interprocess/containers/version_type.hpp>

#### Header <boost/interprocess/creation_tags.hpp>

    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;
      }
    }

#### Header <boost/interprocess/errors.hpp>

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 };

        typedef int native_error_t;
      }
    }

#### Header <boost/interprocess/exceptions.hpp>

Describes exceptions thrown by interprocess classes

    namespace boost {
      namespace interprocess {
        class bad_alloc;
        class interprocess_exception;
        class lock_exception;
      }
    }

#### Header <boost/interprocess/file_mapping.hpp>

Describes file_mapping and mapped region classes

    namespace boost {
      namespace interprocess {
        class file_mapping;
      }
    }

#### Header <boost/interprocess/indexes/flat_map_index.hpp>

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;
      }
    }

#### Header <boost/interprocess/indexes/iset_index.hpp>

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;
      }
    }

#### Header <boost/interprocess/indexes/iunordered_set_index.hpp>

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;
      }
    }

#### Header <boost/interprocess/indexes/map_index.hpp>

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;
      }
    }

#### Header <boost/interprocess/indexes/null_index.hpp>

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;
      }
    }

#### Header <boost/interprocess/indexes/unordered_map_index.hpp>

Describes index adaptor of boost::unordered_map container, to use it as name/shared memory index

    namespace boost {
      namespace interprocess {
        template<typename MapConfig> class unordered_map_index;
      }
    }

#### Header <boost/interprocess/interprocess_fwd.hpp>

This header file forward declares the basic interprocess types:

- boost::interprocess::offset_ptr;

- boost::interprocess::permissions;

- boost::interprocess::mapped_region;

- boost::interprocess::file_mapping;

- boost::interprocess::shared_memory_object;

- boost::interprocess::windows_shared_memory;

- boost::interprocess::xsi_shared_memory;

The following synchronization mechanisms and locks:

- boost::interprocess::null_mutex;

- boost::interprocess::interprocess_mutex;

- boost::interprocess::interprocess_recursive_mutex;

- boost::interprocess::interprocess_semaphore;

- boost::interprocess::named_mutex;

- boost::interprocess::named_recursive_mutex;

- boost::interprocess::named_semaphore;

- boost::interprocess::interprocess_sharable_mutex;

- boost::interprocess::interprocess_condition;

- boost::interprocess::scoped_lock;

- boost::interprocess::sharable_lock;

- boost::interprocess::upgradable_lock;

The following mutex families:

- boost::interprocess::mutex_family;

- boost::interprocess::null_mutex_family;

The following allocators:

- boost::interprocess::allocator;

- boost::interprocess::node_allocator;

- boost::interprocess::private_node_allocator;

- boost::interprocess::cached_node_allocator;

- boost::interprocess::adaptive_pool;

- boost::interprocess::private_adaptive_pool;

- boost::interprocess::cached_adaptive_pool;

The following allocation algorithms:

- boost::interprocess::simple_seq_fit;

- boost::interprocess::rbtree_best_fit;

The following index types:

- boost::interprocess::flat_map_index;

- boost::interprocess::iset_index;

- boost::interprocess::iunordered_set_index;

- boost::interprocess::map_index;

- boost::interprocess::null_index;

- boost::interprocess::unordered_map_index;

The following managed memory types:

- boost::interprocess::segment_manager;

- boost::interprocess::basic_managed_external_buffer

- boost::interprocess::managed_external_buffer

- boost::interprocess::wmanaged_external_buffer

- boost::interprocess::basic_managed_shared_memory

- boost::interprocess::managed_shared_memory

- boost::interprocess::wmanaged_shared_memory

- boost::interprocess::basic_managed_windows_shared_memory

- boost::interprocess::managed_windows_shared_memory

- boost::interprocess::wmanaged_windows_shared_memory

- boost::interprocess::basic_managed_xsi_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::basic_managed_heap_memory

- boost::interprocess::managed_heap_memory

- boost::interprocess::wmanaged_heap_memory

- boost::interprocess::basic_managed_mapped_file

- boost::interprocess::managed_mapped_file

- boost::interprocess::wmanaged_mapped_file

The following exception types:

- boost::interprocess::interprocess_exception

- boost::interprocess::lock_exception

- boost::interprocess::bad_alloc

The following stream types:

- boost::interprocess::basic_bufferbuf

- boost::interprocess::basic_ibufferstream

- boost::interprocess::basic_obufferstream

- boost::interprocess::basic_bufferstream

- boost::interprocess::basic_vectorbuf

- boost::interprocess::basic_ivectorstream

- boost::interprocess::basic_ovectorstream

- boost::interprocess::basic_vectorstream

The following smart pointer types:

- boost::interprocess::scoped_ptr

- boost::interprocess::intrusive_ptr

- boost::interprocess::shared_ptr

- boost::interprocess::weak_ptr

The following interprocess communication types:

- boost::interprocess::message_queue_t;

- boost::interprocess::message_queue;

#### Header <boost/interprocess/ipc/message_queue.hpp>

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;
        typedef message_queue_t< offset_ptr< void > > message_queue;
      }
    }

#### Header <boost/interprocess/managed_external_buffer.hpp>

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;
      }
    }

#### Header <boost/interprocess/managed_heap_memory.hpp>

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;
      }
    }

#### Header <boost/interprocess/managed_mapped_file.hpp>

    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;
      }
    }

#### Header <boost/interprocess/managed_shared_memory.hpp>

    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;
      }
    }

#### Header <boost/interprocess/managed_windows_shared_memory.hpp>

    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;
      }
    }

#### Header <boost/interprocess/managed_xsi_shared_memory.hpp>

    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;
      }
    }

#### Header <boost/interprocess/mapped_region.hpp>

Describes mapped region class

    namespace boost {
      namespace interprocess {
        class mapped_region;
      }
    }

#### Header <boost/interprocess/mem_algo/rbtree_best_fit.hpp>

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;
      }
    }

#### Header <boost/interprocess/mem_algo/simple_seq_fit.hpp>

Describes sequential fit algorithm used to allocate objects in shared memory.

    namespace boost {
      namespace interprocess {
        template<typename MutexFamily, typename VoidPointer> class simple_seq_fit;
      }
    }

#### Header <boost/interprocess/offset_ptr.hpp>

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);
      }
    }

#### Header <boost/interprocess/permissions.hpp>

Describes permissions class

    namespace boost {
      namespace interprocess {
        class permissions;
      }
    }

#### Header <boost/interprocess/segment_manager.hpp>

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;
      }
    }

#### Header <boost/interprocess/shared_memory_object.hpp>

Describes a shared memory object management class.

    namespace boost {
      namespace interprocess {
        class shared_memory_object;
      }
    }

#### Header <boost/interprocess/smart_ptr/deleter.hpp>

Describes the functor to delete objects from the segment.

    namespace boost {
      namespace interprocess {
        template<typename T, typename SegmentManager> class deleter;
      }
    }

#### Header <boost/interprocess/smart_ptr/enable_shared_from_this.hpp>

Describes an utility to form a shared pointer from this

#### Header <boost/interprocess/smart_ptr/intrusive_ptr.hpp>

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 >);
      }
    }

#### Header <boost/interprocess/smart_ptr/scoped_ptr.hpp>

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 &);
      }
    }

#### Header <boost/interprocess/smart_ptr/shared_ptr.hpp>

Describes the smart pointer shared_ptr

    namespace boost {
      namespace interprocess {
        template<typename T, typename A, typename D> class enable_shared_from_this;

        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 &);
      }
    }

#### Header <boost/interprocess/smart_ptr/unique_ptr.hpp>

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 &);
      }
    }

#### Header <boost/interprocess/smart_ptr/weak_ptr.hpp>

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 &);
      }
    }

#### Header <boost/interprocess/streams/bufferstream.hpp>

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;
      }
    }

#### Header <boost/interprocess/streams/vectorstream.hpp>

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;
      }
    }

#### Header <boost/interprocess/sync/file_lock.hpp>

Describes a class that wraps file locking capabilities.

    namespace boost {
      namespace interprocess {
        class file_lock;
      }
    }

#### Header <boost/interprocess/sync/interprocess_condition.hpp>

Describes process-shared variables interprocess_condition class

    namespace boost {
      namespace interprocess {
        class interprocess_condition;
      }
    }

#### Header <boost/interprocess/sync/interprocess_condition_any.hpp>

Describes process-shared variables interprocess_condition_any class

    namespace boost {
      namespace interprocess {
        class interprocess_condition_any;
      }
    }

#### Header <boost/interprocess/sync/interprocess_mutex.hpp>

Describes a mutex class that can be placed in memory shared by several processes.

    namespace boost {
      namespace interprocess {
        class interprocess_mutex;
      }
    }

#### Header <boost/interprocess/sync/interprocess_recursive_mutex.hpp>

Describes interprocess_recursive_mutex and shared_recursive_try_mutex classes

    namespace boost {
      namespace interprocess {
        class interprocess_recursive_mutex;
      }
    }

#### Header <boost/interprocess/sync/interprocess_semaphore.hpp>

Describes a interprocess_semaphore class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class interprocess_semaphore;
      }
    }

#### Header <boost/interprocess/sync/interprocess_sharable_mutex.hpp>

Describes interprocess_sharable_mutex class

    namespace boost {
      namespace interprocess {
        class interprocess_sharable_mutex;
      }
    }

#### Header <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>

Describes interprocess_upgradable_mutex class

    namespace boost {
      namespace interprocess {
        class interprocess_upgradable_mutex;
      }
    }

#### Header <boost/interprocess/sync/lock_options.hpp>

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;
      }
    }

#### Header <boost/interprocess/sync/mutex_family.hpp>

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;
      }
    }

#### Header <boost/interprocess/sync/named_condition.hpp>

Describes a named condition class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_condition;
      }
    }

#### Header <boost/interprocess/sync/named_condition_any.hpp>

Describes a named condition class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_condition_any;
      }
    }

#### Header <boost/interprocess/sync/named_mutex.hpp>

Describes a named mutex class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_mutex;
      }
    }

#### Header <boost/interprocess/sync/named_recursive_mutex.hpp>

Describes a named named_recursive_mutex class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_recursive_mutex;
      }
    }

#### Header <boost/interprocess/sync/named_semaphore.hpp>

Describes a named semaphore class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_semaphore;
      }
    }

#### Header <boost/interprocess/sync/named_sharable_mutex.hpp>

Describes a named sharable mutex class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_sharable_mutex;
      }
    }

#### Header <boost/interprocess/sync/named_upgradable_mutex.hpp>

Describes a named upgradable mutex class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_upgradable_mutex;
      }
    }

#### Header <boost/interprocess/sync/null_mutex.hpp>

Describes null_mutex classes

    namespace boost {
      namespace interprocess {
        class null_mutex;
      }
    }

#### Header <boost/interprocess/sync/scoped_lock.hpp>

Describes the scoped_lock class.

    namespace boost {
      namespace interprocess {
        template<typename Mutex> class scoped_lock;
      }
    }

#### Header <boost/interprocess/sync/sharable_lock.hpp>

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;
      }
    }

#### Header <boost/interprocess/sync/upgradable_lock.hpp>

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;
      }
    }

#### Header <boost/interprocess/windows_shared_memory.hpp>

Describes a class representing a native windows shared memory.

    namespace boost {
      namespace interprocess {
        class windows_shared_memory;
      }
    }

#### Header <boost/interprocess/xsi_key.hpp>

Describes a class representing a xsi key type.

    namespace boost {
      namespace interprocess {
        class xsi_key;
      }
    }

#### Header <boost/interprocess/xsi_shared_memory.hpp>

Describes a class representing a native xsi shared memory.

    namespace boost {
      namespace interprocess {
        class xsi_shared_memory;
      }
    }