Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Indexes and Reference

Indexes
Boost.Interprocess Header Reference

Class Index

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

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

Typedef Index

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

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

Function Index

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

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

Boost.Interprocess Header Reference

Header <boost/interprocess/allocators/adaptive_pool.hpp>
Header <boost/interprocess/allocators/allocator.hpp>
Header <boost/interprocess/allocators/cached_adaptive_pool.hpp>
Header <boost/interprocess/allocators/cached_node_allocator.hpp>
Header <boost/interprocess/allocators/node_allocator.hpp>
Header <boost/interprocess/allocators/private_adaptive_pool.hpp>
Header <boost/interprocess/allocators/private_node_allocator.hpp>
Header <boost/interprocess/anonymous_shared_memory.hpp>
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>
Header <boost/interprocess/errors.hpp>
Header <boost/interprocess/exceptions.hpp>
Header <boost/interprocess/file_mapping.hpp>
Header <boost/interprocess/indexes/flat_map_index.hpp>
Header <boost/interprocess/indexes/iset_index.hpp>
Header <boost/interprocess/indexes/iunordered_set_index.hpp>
Header <boost/interprocess/indexes/map_index.hpp>
Header <boost/interprocess/indexes/null_index.hpp>
Header <boost/interprocess/indexes/unordered_map_index.hpp>
Header <boost/interprocess/interprocess_fwd.hpp>
Header <boost/interprocess/ipc/message_queue.hpp>
Header <boost/interprocess/managed_external_buffer.hpp>
Header <boost/interprocess/managed_heap_memory.hpp>
Header <boost/interprocess/managed_mapped_file.hpp>
Header <boost/interprocess/managed_shared_memory.hpp>
Header <boost/interprocess/managed_windows_shared_memory.hpp>
Header <boost/interprocess/managed_xsi_shared_memory.hpp>
Header <boost/interprocess/mapped_region.hpp>
Header <boost/interprocess/mem_algo/rbtree_best_fit.hpp>
Header <boost/interprocess/mem_algo/simple_seq_fit.hpp>
Header <boost/interprocess/offset_ptr.hpp>
Header <boost/interprocess/permissions.hpp>
Header <boost/interprocess/segment_manager.hpp>
Header <boost/interprocess/shared_memory_object.hpp>
Header <boost/interprocess/smart_ptr/deleter.hpp>
Header <boost/interprocess/smart_ptr/enable_shared_from_this.hpp>
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/unique_ptr.hpp>
Header <boost/interprocess/smart_ptr/weak_ptr.hpp>
Header <boost/interprocess/streams/bufferstream.hpp>
Header <boost/interprocess/streams/vectorstream.hpp>
Header <boost/interprocess/sync/file_lock.hpp>
Header <boost/interprocess/sync/interprocess_condition.hpp>
Header <boost/interprocess/sync/interprocess_condition_any.hpp>
Header <boost/interprocess/sync/interprocess_mutex.hpp>
Header <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
Header <boost/interprocess/sync/interprocess_semaphore.hpp>
Header <boost/interprocess/sync/interprocess_sharable_mutex.hpp>
Header <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>
Header <boost/interprocess/sync/lock_options.hpp>
Header <boost/interprocess/sync/mutex_family.hpp>
Header <boost/interprocess/sync/named_condition.hpp>
Header <boost/interprocess/sync/named_condition_any.hpp>
Header <boost/interprocess/sync/named_mutex.hpp>
Header <boost/interprocess/sync/named_recursive_mutex.hpp>
Header <boost/interprocess/sync/named_semaphore.hpp>
Header <boost/interprocess/sync/named_sharable_mutex.hpp>
Header <boost/interprocess/sync/named_upgradable_mutex.hpp>
Header <boost/interprocess/sync/null_mutex.hpp>
Header <boost/interprocess/sync/scoped_lock.hpp>
Header <boost/interprocess/sync/sharable_lock.hpp>
Header <boost/interprocess/sync/upgradable_lock.hpp>
Header <boost/interprocess/windows_shared_memory.hpp>
Header <boost/interprocess/xsi_key.hpp>
Header <boost/interprocess/xsi_shared_memory.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 > &);
  }
}

Describes an allocator that allocates portions of fixed size memory buffer (shared memory, mapped file...)

namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager> class allocator;
    template<typename T, typename SegmentManager> 
      bool operator==(const allocator< T, SegmentManager > &, 
                      const allocator< T, SegmentManager > &);
    template<typename T, typename SegmentManager> 
      bool operator!=(const allocator< T, SegmentManager > &, 
                      const allocator< T, SegmentManager > &);
  }
}

Describes cached_adaptive_pool pooled shared memory STL compatible allocator

namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
             std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
      class cached_adaptive_pool;
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             std::size_t OP> 
      bool operator==(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             std::size_t OP> 
      bool operator!=(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
  }
}

Describes cached_cached_node_allocator pooled shared memory STL compatible allocator

namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
      class cached_node_allocator;
    template<typename T, typename S, std::size_t NPC> 
      bool operator==(const cached_node_allocator< T, S, NPC > &, 
                      const cached_node_allocator< T, S, NPC > &);
    template<typename T, typename S, std::size_t NPC> 
      bool operator!=(const cached_node_allocator< T, S, NPC > &, 
                      const cached_node_allocator< T, S, NPC > &);
  }
}

Describes node_allocator pooled shared memory STL compatible allocator

namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
      class node_allocator;
    template<typename T, typename S, std::size_t NPC> 
      bool operator==(const node_allocator< T, S, NPC > &, 
                      const node_allocator< T, S, NPC > &);
    template<typename T, typename S, std::size_t NPC> 
      bool operator!=(const node_allocator< T, S, NPC > &, 
                      const node_allocator< T, S, NPC > &);
  }
}

Describes private_adaptive_pool_base pooled shared memory STL compatible allocator

namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
             std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
      class private_adaptive_pool;
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator==(const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator!=(const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
  }
}

Describes private_node_allocator_base pooled shared memory STL compatible allocator

namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
      class private_node_allocator;
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator==(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, 
                      const private_node_allocator< T, S, NodesPerBlock, F, OP > &);
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator!=(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, 
                      const private_node_allocator< T, S, NodesPerBlock, F, OP > &);
  }
}

Describes a function that creates anonymous shared memory that can be shared between forked processes

namespace boost {
  namespace interprocess {
    mapped_region anonymous_shared_memory(std::size_t, void * = 0);
  }
}
namespace boost {
  namespace interprocess {
    struct create_only_t;
    struct open_copy_on_write_t;
    struct open_only_t;
    struct open_or_create_t;
    struct open_read_only_t;
    struct open_read_private_t;

    static const create_only_t create_only;
    static const open_only_t open_only;
    static const open_read_only_t open_read_only;
    static const open_or_create_t open_or_create;
    static const open_copy_on_write_t open_copy_on_write;
  }
}

Describes the error numbering of interprocess classes

namespace boost {
  namespace interprocess {

    enum error_code_t { no_error = = 0, system_error, other_error, 
                        security_error, read_only_error, io_error, path_error, 
                        not_found_error, busy_error, already_exists_error, 
                        not_empty_error, is_directory_error, 
                        out_of_space_error, out_of_memory_error, 
                        out_of_resource_error, lock_error, sem_error, 
                        mode_error, size_error, corrupted_error, 
                        not_such_file_or_directory, invalid_argument, 
                        timeout_when_locking_error, 
                        timeout_when_waiting_error, owner_dead_error };

    typedef int native_error_t;
  }
}

Describes exceptions thrown by interprocess classes

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

Describes file_mapping and mapped region classes

namespace boost {
  namespace interprocess {
    class file_mapping;
  }
}

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

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

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

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

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

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

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

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

Describes a null index adaptor, so that if we don't want to construct named objects, we can use this null index type to save resources.

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

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

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:

The following exception types:

The following stream types:

The following smart pointer types:

The following interprocess communication types:

Describes an inter-process message queue. This class allows sending messages between processes and allows blocking, non-blocking and timed sending and receiving.

namespace boost {
  namespace interprocess {
    template<typename VoidPointer> class message_queue_t;
    typedef message_queue_t< offset_ptr< void > > message_queue;
  }
}

Describes a named user memory allocation user class.

namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_external_buffer;
    typedef basic_managed_external_buffer< char,rbtree_best_fit< null_mutex_family >,iset_index > managed_external_buffer;
    typedef basic_managed_external_buffer< wchar_t,rbtree_best_fit< null_mutex_family >,iset_index > wmanaged_external_buffer;
  }
}

Describes a named heap memory allocation user class.

namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_heap_memory;
    typedef basic_managed_heap_memory< char,rbtree_best_fit< null_mutex_family >,iset_index > managed_heap_memory;
    typedef basic_managed_heap_memory< wchar_t,rbtree_best_fit< null_mutex_family >,iset_index > wmanaged_heap_memory;
  }
}
namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_mapped_file;
    typedef basic_managed_mapped_file< char,rbtree_best_fit< mutex_family >,iset_index > managed_mapped_file;
    typedef basic_managed_mapped_file< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_mapped_file;
  }
}
namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_shared_memory;
    typedef basic_managed_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_shared_memory;
    typedef basic_managed_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_shared_memory;
    typedef basic_managed_shared_memory< char,rbtree_best_fit< mutex_family, void * >,iset_index > fixed_managed_shared_memory;
    typedef basic_managed_shared_memory< wchar_t,rbtree_best_fit< mutex_family, void * >,iset_index > wfixed_managed_shared_memory;
  }
}
namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_windows_shared_memory;
    typedef basic_managed_windows_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_windows_shared_memory;
    typedef basic_managed_windows_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_windows_shared_memory;
  }
}
namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_xsi_shared_memory;
    typedef basic_managed_xsi_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_xsi_shared_memory;
    typedef basic_managed_xsi_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_xsi_shared_memory;
  }
}

Describes mapped region class

namespace boost {
  namespace interprocess {
    class mapped_region;
  }
}

Describes a best-fit algorithm based in an intrusive red-black tree used to allocate objects in shared memory. This class is intended as a base class for single segment and multi-segment implementations.

namespace boost {
  namespace interprocess {
    template<typename MutexFamily, typename VoidPointer, 
             std::size_t MemAlignment> 
      class rbtree_best_fit;
  }
}

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

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

Describes a smart pointer that stores the offset between this pointer and target pointee, called offset_ptr.

namespace boost {
  namespace interprocess {
    template<typename PointedType, typename DifferenceType, 
             typename OffsetType, std::size_t OffsetAlignment> 
      class offset_ptr;
    template<typename E, typename T, typename W, typename X, typename Y, 
             std::size_t Z> 
      std::basic_ostream< E, T > & 
      operator<<(std::basic_ostream< E, T > &, 
                 offset_ptr< W, X, Y, Z > const &);
    template<typename E, typename T, typename W, typename X, typename Y, 
             std::size_t Z> 
      std::basic_istream< E, T > & 
      operator>>(std::basic_istream< E, T > &, offset_ptr< W, X, Y, Z > &);

    // Simulation of static_cast between pointers. Never throws. 
    template<typename T1, typename P1, typename O1, std::size_t A1, 
             typename T2, typename P2, typename O2, std::size_t A2> 
      boost::interprocess::offset_ptr< T1, P1, O1, A1 > 
      static_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r);

    // Simulation of const_cast between pointers. Never throws. 
    template<typename T1, typename P1, typename O1, std::size_t A1, 
             typename T2, typename P2, typename O2, std::size_t A2> 
      boost::interprocess::offset_ptr< T1, P1, O1, A1 > 
      const_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r);

    // Simulation of dynamic_cast between pointers. Never throws. 
    template<typename T1, typename P1, typename O1, std::size_t A1, 
             typename T2, typename P2, typename O2, std::size_t A2> 
      boost::interprocess::offset_ptr< T1, P1, O1, A1 > 
      dynamic_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r);

    // Simulation of reinterpret_cast between pointers. Never throws. 
    template<typename T1, typename P1, typename O1, std::size_t A1, 
             typename T2, typename P2, typename O2, std::size_t A2> 
      boost::interprocess::offset_ptr< T1, P1, O1, A1 > 
      reinterpret_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r);
  }
}

Describes permissions class

namespace boost {
  namespace interprocess {
    class permissions;
  }
}

Describes the object placed in a memory segment that provides named object allocation capabilities for single-segment and multi-segment allocations.

namespace boost {
  namespace interprocess {
    template<typename CharType, typename MemoryAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class segment_manager;
    template<typename MemoryAlgorithm> class segment_manager_base;
  }
}

Describes a shared memory object management class.

namespace boost {
  namespace interprocess {
    class shared_memory_object;
  }
}

Describes the functor to delete objects from the segment.

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

Describes an utility to form a shared pointer from this

Describes an intrusive ownership pointer.

namespace boost {
  namespace interprocess {
    template<typename T, typename VoidPointer> class intrusive_ptr;
    template<typename T, typename U, typename VP> 
      bool operator==(intrusive_ptr< T, VP > const &, 
                      intrusive_ptr< U, VP > const &);
    template<typename T, typename U, typename VP> 
      bool operator!=(intrusive_ptr< T, VP > const &, 
                      intrusive_ptr< U, VP > const &);
    template<typename T, typename VP> 
      bool operator==(intrusive_ptr< T, VP > const &, 
                      const typename intrusive_ptr< T, VP >::pointer &);
    template<typename T, typename VP> 
      bool operator!=(intrusive_ptr< T, VP > const &, 
                      const typename intrusive_ptr< T, VP >::pointer &);
    template<typename T, typename VP> 
      bool operator==(const typename intrusive_ptr< T, VP >::pointer &, 
                      intrusive_ptr< T, VP > const &);
    template<typename T, typename VP> 
      bool operator!=(const typename intrusive_ptr< T, VP >::pointer &, 
                      intrusive_ptr< T, VP > const &);
    template<typename T, typename VP> 
      bool operator<(intrusive_ptr< T, VP > const &, 
                     intrusive_ptr< T, VP > const &);
    template<typename T, typename VP> 
      void swap(intrusive_ptr< T, VP > &, intrusive_ptr< T, VP > &);
    template<typename E, typename T, typename Y, typename VP> 
      std::basic_ostream< E, T > & 
      operator<<(std::basic_ostream< E, T > & os, 
                 intrusive_ptr< Y, VP > const & p);
    template<typename T, typename VP> 
      boost::interprocess::intrusive_ptr< T, VP >::pointer 
      to_raw_pointer(intrusive_ptr< T, VP >);
  }
}

Describes the smart pointer scoped_ptr

namespace boost {
  namespace interprocess {
    template<typename T, typename Deleter> class scoped_ptr;
    template<typename T, typename D> 
      void swap(scoped_ptr< T, D > &, scoped_ptr< T, D > &);
    template<typename T, typename D> 
      scoped_ptr< T, D >::pointer to_raw_pointer(scoped_ptr< T, D > const &);
  }
}

Describes the smart pointer shared_ptr

namespace boost {
  namespace interprocess {
    template<typename T, typename 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 &);
  }
}

This header provides utilities to define a unique_ptr that plays nicely with managed segments.

namespace boost {
  namespace interprocess {
    template<typename T, typename ManagedMemory> struct managed_unique_ptr;
    template<typename T, typename ManagedMemory> 
      managed_unique_ptr< T, ManagedMemory >::type 
      make_managed_unique_ptr(T *, ManagedMemory &);
  }
}

Describes the smart pointer weak_ptr.

namespace boost {
  namespace interprocess {
    template<typename T, typename ManagedMemory> struct managed_weak_ptr;

    template<typename T, typename A, typename D> class weak_ptr;
    template<typename T, typename A, typename D, typename U, typename A2, 
             typename D2> 
      bool operator<(weak_ptr< T, A, D > const & a, 
                     weak_ptr< U, A2, D2 > const & b);
    template<typename T, typename A, typename D> 
      void swap(weak_ptr< T, A, D > & a, weak_ptr< T, A, D > & b);
    template<typename T, typename ManagedMemory> 
      managed_weak_ptr< T, ManagedMemory >::type 
      make_managed_weak_ptr(T *, ManagedMemory &);
  }
}

This file defines basic_bufferbuf, basic_ibufferstream, basic_obufferstream, and basic_bufferstream classes. These classes represent streamsbufs and streams whose sources or destinations are fixed size character buffers.

namespace boost {
  namespace interprocess {
    template<typename CharT, typename CharTraits> class basic_bufferbuf;
    template<typename CharT, typename CharTraits> class basic_bufferstream;
    template<typename CharT, typename CharTraits> class basic_ibufferstream;
    template<typename CharT, typename CharTraits> class basic_obufferstream;

    typedef basic_bufferbuf< char > bufferbuf;
    typedef basic_bufferstream< char > bufferstream;
    typedef basic_ibufferstream< char > ibufferstream;
    typedef basic_obufferstream< char > obufferstream;
    typedef basic_bufferbuf< wchar_t > wbufferbuf;
    typedef basic_bufferstream< wchar_t > wbufferstream;
    typedef basic_ibufferstream< wchar_t > wibufferstream;
    typedef basic_obufferstream< wchar_t > wobufferstream;
  }
}

This file defines basic_vectorbuf, basic_ivectorstream, basic_ovectorstream, and basic_vectorstreamclasses. These classes represent streamsbufs and streams whose sources or destinations are STL-like vectors that can be swapped with external vectors to avoid unnecessary allocations/copies.

namespace boost {
  namespace interprocess {
    template<typename CharVector, typename CharTraits> 
      class basic_ivectorstream;
    template<typename CharVector, typename CharTraits> 
      class basic_ovectorstream;
    template<typename CharVector, typename CharTraits> class basic_vectorbuf;
    template<typename CharVector, typename CharTraits> class basic_vectorstream;
  }
}

Describes a class that wraps file locking capabilities.

namespace boost {
  namespace interprocess {
    class file_lock;
  }
}

Describes process-shared variables interprocess_condition class

namespace boost {
  namespace interprocess {
    class interprocess_condition;
  }
}

Describes process-shared variables interprocess_condition_any class

namespace boost {
  namespace interprocess {
    class interprocess_condition_any;
  }
}

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

namespace boost {
  namespace interprocess {
    class interprocess_mutex;
  }
}

Describes interprocess_recursive_mutex and shared_recursive_try_mutex classes

namespace boost {
  namespace interprocess {
    class interprocess_recursive_mutex;
  }
}

Describes a interprocess_semaphore class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class interprocess_semaphore;
  }
}

Describes interprocess_sharable_mutex class

namespace boost {
  namespace interprocess {
    class interprocess_sharable_mutex;
  }
}

Describes interprocess_upgradable_mutex class

namespace boost {
  namespace interprocess {
    class interprocess_upgradable_mutex;
  }
}

Describes the lock options with associated with interprocess_mutex lock constructors.

namespace boost {
  namespace interprocess {
    struct accept_ownership_type;
    struct defer_lock_type;
    struct try_to_lock_type;

    static const defer_lock_type defer_lock;
    static const try_to_lock_type try_to_lock;
    static const accept_ownership_type accept_ownership;
  }
}

Describes a shared interprocess_mutex family fit algorithm used to allocate objects in shared memory.

namespace boost {
  namespace interprocess {
    struct mutex_family;
    struct null_mutex_family;
  }
}

Describes a named condition class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_condition;
  }
}

Describes a named condition class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_condition_any;
  }
}

Describes a named mutex class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_mutex;
  }
}

Describes a named named_recursive_mutex class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_recursive_mutex;
  }
}

Describes a named semaphore class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_semaphore;
  }
}

Describes a named sharable mutex class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_sharable_mutex;
  }
}

Describes a named upgradable mutex class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_upgradable_mutex;
  }
}

Describes null_mutex classes

namespace boost {
  namespace interprocess {
    class null_mutex;
  }
}

Describes the scoped_lock class.

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

Describes the upgradable_lock class that serves to acquire the upgradable lock of a mutex.

namespace boost {
  namespace interprocess {
    template<typename SharableMutex> class sharable_lock;
  }
}

Describes the upgradable_lock class that serves to acquire the upgradable lock of a mutex.

namespace boost {
  namespace interprocess {
    template<typename UpgradableMutex> class upgradable_lock;
  }
}

Describes a class representing a native windows shared memory.

namespace boost {
  namespace interprocess {
    class windows_shared_memory;
  }
}

Describes a class representing a xsi key type.

namespace boost {
  namespace interprocess {
    class xsi_key;
  }
}

Describes a class representing a native xsi shared memory.

namespace boost {
  namespace interprocess {
    class xsi_shared_memory;
  }
}

PrevUpHomeNext