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

Acknowledgements, notes and links

Notes
Indexes and Reference

Boost.Interprocess uses the Windows COM library to implement some features and initializes it with concurrency model COINIT_APARTMENTTHREADED. If the COM library was already initialized by the calling thread for another concurrency model, Boost.Interprocess handles this gracefully and uses COM calls for the already initialized model. If for some reason, you want Boost.Interprocess to initialize the COM library with another model, define the macro BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL before including Boost.Interprocess to one of these values:

  • COINIT_APARTMENTTHREADED_BIPC
  • COINIT_MULTITHREADED_BIPC
  • COINIT_DISABLE_OLE1DDE_BIPC
  • COINIT_SPEED_OVER_MEMORY_BIPC

Shared memory (shared_memory_object) is implemented in windows using memory mapped files, placed in a shared directory in the shared documents folder (SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders\Common AppData). This directory name is the last bootup time obtained via COM calls (if BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME) defined or searching the system log for a startup event (the default implementation), so that each bootup shared memory is created in a new folder obtaining kernel persistence shared memory.

If using BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME, due to COM implementation related errors, in Boost 1.48 & Boost 1.49 the bootup-time folder was dumped and files were directly created in shared documents folder, reverting to filesystem persistence shared memory. Boost 1.50 fixed those issues and recovered bootup time directory and kernel persistence. If you need to reproduce Boost 1.48 & Boost 1.49 behaviour to communicate with applications compiled with that version, comment #define BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME directive in the Windows configuration part of boost/interprocess/detail/workaround.hpp.

If using the default implementation, (BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME undefined) and the Startup Event is not found, this might be due to some buggy software that floods or erases the event log.

In any error case (shared documents folder is not defined or bootup time could not be obtained, the library throws an error. You still can use Boost.Interprocess definining your own directory as the shared directory. Just define BOOST_INTERPROCESS_SHARED_DIR_PATH when using the library and that path will be used to place shared memory files.

If BOOST_USE_WINDOWS_H is defined, <windows.h> and other windows SDK files are included, otherwise the library declares needed functions and structures to reduce the impact of including those heavy headers.

On systems without POSIX shared memory support shared memory objects are implemented as memory mapped files, using a directory placed in "/tmp" that can include (if BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME is defined) the last bootup time (if the Os supports it). As in Windows, in any error case obtaining this directory the library throws an error . You still can use Boost.Interprocess definining your own directory as the shared directory. Just define BOOST_INTERPROCESS_SHARED_DIR_PATH when using the library and that path will be used to place shared memory files.

The committed address space is the total amount of virtual memory (swap or physical memory/RAM) that the kernel might have to supply if all applications decide to access all of the memory they've requested from the kernel. By default, Linux allows processes to commit more virtual memory than available in the system. If that memory is not accessed, no physical memory + swap is actually used.

The reason for this behaviour is that Linux tries to optimize memory usage on forked processes; fork() creates a full copy of the process space, but with overcommitted memory, in this new forked instance only pages which have been written to actually need to be allocated by the kernel. If applications access more memory than available, then the kernel must free memory in the hard way: the OOM (Out Of Memory)-killer picks some processes to kill in order to recover memory.

Boost.Interprocess has no way to change this behaviour and users might suffer the OOM-killer when accessing shared memory. According to the Kernel documentation, the Linux kernel supports several overcommit modes. If you need non-kill guarantees in your application, you should change this overcommit behaviour.

Many people have contributed with ideas and revisions, so this is the place to thank them:

  • Thanks to all people who have shown interest in the library and have downloaded and tested the snapshots.
  • Thanks to Francis Andre and Anders Hybertz for their ideas and suggestions. Many of them are not implemented yet but I hope to include them when library gets some stability.
  • Thanks to Matt Doyle, Steve LoBasso, Glenn Schrader, Hiang Swee Chiang, Phil Endecott, Rene Rivera, Harold Pirtle, Paul Ryan, Shumin Wu, Michal Wozniak, Peter Johnson, Alex Ott, Shane Guillory, Steven Wooding and Kim Barrett for their bug fixes and library testing.
  • Thanks to Martin Adrian who suggested the use of Interprocess framework for user defined buffers.
  • Thanks to Synge Todo for his boostbook-doxygen patch to improve Interprocess documentation.
  • Thanks to Olaf Krzikalla for his Intrusive library. I have taken some ideas to improve red black tree implementation from his library.
  • Thanks to Daniel James for his unordered_map/set family and his help with allocators. His great unordered implementation has been a reference to design exception safe containers.
  • Thanks to Howard Hinnant for his amazing help, specially explaining allocator swapping, move semantics and for developing upgradable mutex and lock transfer features.
  • Thanks to Pavel Vozenilek for his continuous review process, suggestions, code and help. He is the major supporter of Interprocess library. The library has grown with his many and great advices.
  • And finally, thank you to all Boosters. Long live to C++!
  • Fixed bugs #7156 ("interprocess buffer streams leak memory on construction"]). #7164 ("Two potential bugs with b::int::vector of b::i::weak_ptr"]). #7860 ("smart_ptr's yield_k and spinlock utilities can improve spinlock-based sychronization primitives"]). #8277 ("docs for named_mutex erroneously refer to interprocess_mutex"]). #8976 ("shared_ptr fails to compile if used with a scoped_allocator"]). #9008 ("conditions variables fast enough only when opening a multiprocess browser"]). #9065 ("atomic_cas32 inline assembly wrong on ppc32"]). #9073 ("Conflict names 'realloc'"]).
  • Added support for platform-specific flags to mapped_region (ticket #8030)
  • Fixed bugs #7484, #7598, #7682, #7923, #7924, #7928, #7936, #8521, #8595.
  • ABI breaking: Changed bootstamp function in Windows to use EventLog service start time as system bootup time. Previously used LastBootupTime from WMI was unstable with time synchronization and hibernation and unusable in practice. If you really need to obtain pre Boost 1.54 behaviour define BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME from command line or detail/workaround.hpp.
  • Fixed GCC -Wshadow warnings.
  • Experimental multiple allocation interface improved and changed again. Still unstable.
  • Replaced deprecated BOOST_NO_XXXX with newer BOOST_NO_CXX11_XXX macros.
  • ABI breaking: changed node pool allocators internals for improved efficiency.
  • Fixed bug #7795.
  • Added shrink_by and advise functions in mapped_region.
  • ABI breaking: Reimplemented message_queue with a circular buffer index (the old behavior used an ordered array, leading to excessive copies). This should greatly increase performance but breaks ABI. Old behaviour/ABI can be used undefining macro BOOST_INTERPROCESS_MSG_QUEUE_CIRCULAR_INDEX in boost/interprocess/detail/workaround.hpp
  • Improved message_queue insertion time avoiding priority search for common cases (both array and circular buffer configurations).
  • Implemented interproces_sharable_mutex and interproces_condition_any.
  • Improved offset_ptr performance.
  • Added integer overflow checks.
  • Fixed bugs #3750, #6727, #6648,
  • Shared memory in windows has again kernel persistence: kernel bootstamp and WMI has received some fixes and optimizations. This causes incompatibility with Boost 1.48 and 1.49 but the user can comment #define BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME in the windows configuration part to get Boost 1.48 & Boost 1.49 behaviour.
  • Fixed bugs #2796, #4031, #4251, #4452, #4895, #5077, #5120, #5123, #5230, #5197, #5287, #5294, #5306, #5308, #5392, #5409,
  • Added support to customize offset_ptr and allow creating custom managed segments that might be shared between 32 and 64 bit processes.
  • Shared memory in windows has again filesystem lifetime: kernel bootstamp and WMI use to get a reliable timestamp was causing a lot of trouble.
  • Support for POSIX shared memory in Mac OS.
  • ABI breaking: Generic semaphore and named_semaphore now implemented more efficiently with atomic operations.
  • More robust file opening in Windows platforms with active Anti-virus software.
  • Windows shared memory is created in Shared Documents folder so that it can be shared between services and processes
  • Fixed bugs #2967, #2973, #2992, #3138, #3166, #3205.
  • Added experimental stable_vector container.
  • shared_memory_object::remove has now POSIX unlink semantics and file_mapping::remove was added to obtain POSIX unlink semantics with mapped files.
  • Shared memory in windows has now kernel lifetime instead of filesystem lifetime: shared memory will disappear when the system reboots.
  • Updated move semantics.
  • Fixed bugs #2722, #2729, #2766, #1390, #2589,
  • Updated documentation to show rvalue-references funcions instead of emulation functions.
  • More non-copyable classes are now movable.
  • Move-constructor and assignments now leave moved object in default-constructed state instead of just swapping contents.
  • Several bugfixes ( #2391, #2431, #1390, #2570, #2528.
  • Containers can be used now in recursive types.
  • Added BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION macro option to force the use of generic emulation code for process-shared synchronization primitives instead of native POSIX functions.
  • Added placement insertion members to containers
  • boost::posix_time::pos_inf value is now handled portably for timed functions.
  • Update some function parameters from iterator to const_iterator in containers to keep up with the draft of the next standard.
  • Documentation fixes.
  • Added anonymous shared memory for UNIX systems.
  • Fixed erroneous void return types from flat_map::erase() functions.
  • Fixed missing move semantics on managed memory classes.
  • Added copy_on_write and open_read_only options for shared memory and mapped file managed classes.
  • ABI breaking: Added to mapped_region the mode used to create it.
  • Corrected instantiation errors in void allocators.
  • shared_ptr is movable and supports aliasing.
  • Added auxiliary utilities to ease the definition and construction of shared_ptr, weak_ptr and unique_ptr. Added explanations and examples of these smart pointers in the documentation.
  • Optimized vector:
    • 1) Now works with raw pointers as much as possible when using allocators defining pointer as an smart pointer. This increases performance and improves compilation times.
    • 2) A bit of metaprogramming to avoid using move_iterator when the type has trivial copy constructor or assignment and improve performance.
    • 3) Changed custom algorithms with standard ones to take advantage of optimized standard algorithms.
    • 4) Removed unused code.
  • ABI breaking: Containers don't derive from allocators, to avoid problems with allocators that might define virtual functions with the same names as container member functions. That would convert container functions in virtual functions and might disallow some of them if the returned type does not lead to a covariant return. Allocators are now stored as base classes of internal structs.
  • Implemented named_mutex and named_semaphore with POSIX named semaphores in systems supporting that option. named_condition has been accordingly changed to support interoperability with named_mutex.
  • Reduced template bloat for node and adaptive allocators extracting node implementation to a class that only depends on the memory algorithm, instead of the segment manager + node size + node number...
  • Fixed bug in mapped_region in UNIX when mapping address was provided but the region was mapped in another address.
  • Added aligned_allocate and allocate_many functions to managed memory segments.
  • Improved documentation about managed memory segments.
  • Boost.Interprocess containers are now documented in the Reference section.
  • Correction of typos and documentation errors.
  • Added get_instance_name, get_instance_length and get_instance_type functions to managed memory segments.
  • Corrected suboptimal buffer expansion bug in rbtree_best_fit.
  • Added iteration of named and unique objects in a segment manager.
  • Fixed leak in vector.
  • Added support for Solaris.
  • Optimized segment_manager to avoid code bloat associated with templated instantiations.
  • Fixed bug for UNIX: No slash ('/') was being added as the first character for shared memory names, leading to errors in some UNIX systems.
  • Fixed bug in VC-8.0: Broken function inlining in core offset_ptr functions.
  • Code examples changed to use new BoostBook code import features.
  • Added aligned memory allocation function to memory algorithms.
  • Fixed bug in deque::clear() and deque::erase(), they were declared private.
  • Fixed bug in deque::erase(). Thanks to Steve LoBasso.
  • Fixed bug in atomic_dec32(). Thanks to Glenn Schrader.
  • Improved (multi)map/(multi)set constructors taking iterators. Now those have linear time if the iterator range is already sorted.
  • ABI breaking: (multi)map/(multi)set now reduce their node size. The color bit is embedded in the parent pointer. Now, the size of a node is the size of 3 pointers in most systems. This optimization is activated for raw and offset_ptr pointers.
  • (multi)map/(multi)set now reuse memory from old nodes in the assignment operator.
  • ABI breaking: Implemented node-containers based on intrusive containers. This saves code size, since many instantiations share the same algorithms.
  • Corrected code to be compilable with Visual C++ 8.0.
  • Added function to zero free memory in memory algorithms and the segment manager. This function is useful for security reasons and to improve compression ratios for files created with managed_mapped_file.
  • Added support for intrusive index types in managed memory segments. Intrusive indexes save extra memory allocations to allocate the index since with just one allocation, we allocate room for the value, the name and the hook to insert the object in the index.
  • Created new index type: iset_index. It's an index based on an intrusive set (rb-tree).
  • Created new index type: iunordered_set_index. It's an index based on a pseudo-intrusive unordered set (hash table).
  • ABI breaking: The intrusive index iset_index is now the default index type.
  • Optimized vector to take advantage of boost::has_trivial_destructor. This optimization avoids calling destructors of elements that have a trivial destructor.
  • Optimized vector to take advantage of has_trivial_destructor_after_move trait. This optimization avoids calling destructors of elements that have a trivial destructor if the element has been moved (which is the case of many movable types). This trick was provided by Howard Hinnant.
  • Added security check to avoid integer overflow bug in allocators and named construction functions.
  • Added alignment checks to forward and backwards expansion functions.
  • Fixed bug in atomic functions for PPC.
  • Fixed race-condition error when creating and opening a managed segment.
  • Added adaptive pools.
  • Source breaking: Changed node allocators' template parameter order to make them easier to use.
  • Added support for native windows shared memory.
  • Added more tests.
  • Corrected the presence of private functions in the reference section.
  • Added function (deallocate_free_chunks()) to manually deallocate completely free chunks from node allocators.
  • Implemented N1780 proposal to LWG issue 233: Insertion hints in associative containers in interprocess multiset and multimap classes.
  • Source breaking: A shared memory object is now used including shared_memory_object.hpp header instead of shared memory.hpp.
  • ABI breaking: Changed global mutex when initializing managed shared memory and memory mapped files. This change tries to minimize deadlocks.
  • Source breaking: Changed shared memory, memory mapped files and mapped region's open mode to a single mode_t type.
  • Added extra WIN32_LEAN_AND_MEAN before including DateTime headers to avoid socket redefinition errors when using Interprocess and Asio in windows.
  • ABI breaking: mapped_region constructor no longer requires classes derived from memory_mappable, but classes must fulfill the MemoryMappable concept.
  • Added in-place reallocation capabilities to basic_string.
  • ABI breaking: Reimplemented and optimized small string optimization. The narrow string class has zero byte overhead with an internal 11 byte buffer in 32 systems!
  • Added move semantics to containers. Improves performance when using containers of containers.
  • ABI breaking: End nodes of node containers (list, slist, map/set) are now embedded in the containers instead of allocated using the allocator. This allows no-throw move-constructors and improves performance.
  • ABI breaking: slist and list containers now have constant-time size() function. The size of the container is added as a member.

Some useful references about the C++ programming language, C++ internals, shared memory, allocators and containers used to design Boost.Interprocess.

  • Great book about multithreading, and POSIX: "Programming with Posix Threads", David R. Butenhof
  • The UNIX inter-process bible: "UNIX Network Programming, Volume 2: Interprocess Communications", W. Richard Stevens
  • Current STL allocator issues: "Effective STL", Scott Meyers
  • My C++ bible: "Thinking in C++, Volume 1 & 2", Bruce Eckel and Chuck Allison
  • The book every C++ programmer should read: "Inside the C++ Object Model", Stanley B. Lippman
  • A must-read: "ISO/IEC TR 18015: Technical Report on C++ Performance", ISO WG21-SC22 members.

There are some Interprocess features that I would like to implement and some Boost.Interprocess code that can be much better. Let's see some ideas:

Win32 version of shared mutexes and shared conditions are based on "spin and wait" atomic instructions. This leads to poor performance and does not manage any issues like priority inversions. We would need very serious help from threading experts on this. And I'm not sure that this can be achieved in user-level software. Posix based implementations use PTHREAD_PROCESS_SHARED attribute to place mutexes in shared memory, so there are no such problems. I'm not aware of any implementation that simulates PTHREAD_PROCESS_SHARED attribute for Win32. We should be able to construct these primitives in memory mapped files, so that we can get filesystem persistence just like with POSIX primitives.

Currently Interprocess only allows char based names for basic named objects. However, several operating systems use wchar_t names for resources (mapped files, for example). In the future Interprocess should try to present a portable narrow/wide char interface. To do this, it would be useful to have a boost wstring <-> string conversion utilities to translate resource names (escaping needed characters that can conflict with OS names) in a portable way. It would be interesting also the use of boost::filesystem paths to avoid operating system specific issues.

Boost.Interprocess does not define security attributes for shared memory and synchronization objects. Standard C++ also ignores security attributes with files so adding security attributes would require some serious work.

Boost.Interprocess offers a process-shared message queue based on Boost.Interprocess primitives like mutexes and conditions. I would want to develop more mechanisms, like stream-oriented named fifo so that we can use it with a iostream-interface wrapper (we can imitate Unix pipes).

C++ needs more complex mechanisms and it would be nice to have a stream and datagram oriented PF_UNIX-like mechanism in C++. And for very fast inter-process remote calls Solaris doors is an interesting alternative to implement for C++. But the work to implement PF_UNIX-like sockets and doors would be huge (and it might be difficult in a user-level library). Any network expert volunteer?

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 V W

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

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

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

Boost.Interprocess 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

template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
         std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
  class adaptive_pool;namespace boost {
  template<typename T, typename SegmentManager, 
           std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, 
           unsigned char OverheadPercent = 5> 
    class adaptive_pool_v1;
  template<unsigned int V, typename T, typename S, std::size_t NPC, 
           std::size_t F, unsigned char OP> 
    bool operator==(const adaptive_pool_base< V, T, S, NPC, F, OP > &, 
                    const adaptive_pool_base< V, T, S, NPC, F, OP > &);
  template<unsigned int V, typename T, typename S, std::size_t NPC, 
           std::size_t F, unsigned char OP> 
    bool operator!=(const adaptive_pool_base< V, T, S, NPC, F, OP > &, 
                    const adaptive_pool_base< V, T, S, NPC, F, OP > &);
  namespace interprocess {
     adaptive_pool_base(segment_manager *);
     adaptive_pool_base(const adaptive_pool_base &);

    // Assignment from other adaptive_pool_base. 
    adaptive_pool_base & operator=(const adaptive_pool_base & other);
    template<typename T2> 
       adaptive_pool_base(const adaptive_pool_base< Version, T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent > &);
     ~adaptive_pool_base();
  }
}
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator==(const adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                  const adaptive_pool< T, S, NodesPerBlock, F, OP > &);
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator!=(const adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                  const adaptive_pool< T, S, NodesPerBlock, F, OP > &);

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

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

Describes cached_adaptive_pool pooled shared memory STL compatible allocator

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

Describes cached_cached_node_allocator pooled shared memory STL compatible allocator

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

Describes node_allocator pooled shared memory STL compatible allocator

template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
  class node_allocator;namespace boost {
  template<typename T, typename SegmentManager, 
           std::size_t NodesPerBlock = 64> 
    class node_allocator_v1;
  template<unsigned int V, typename T, typename S, std::size_t NPC> 
    bool operator==(const node_allocator_base< V, T, S, NPC > &, 
                    const node_allocator_base< V, T, S, NPC > &);
  template<unsigned int V, typename T, typename S, std::size_t NPC> 
    bool operator!=(const node_allocator_base< V, T, S, NPC > &, 
                    const node_allocator_base< V, T, S, NPC > &);
  namespace interprocess {
     BOOST_STATIC_ASSERT((Version<=2));
     node_allocator_base(segment_manager *);
     node_allocator_base(const node_allocator_base &);
    template<typename T2> 
       node_allocator_base(const node_allocator_base< Version, T2, SegmentManager, NodesPerBlock > &);

    // Assignment from other node_allocator_base. 
    node_allocator_base & operator=(const node_allocator_base & other);
     ~node_allocator_base();
  }
}
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

template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
         std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
  class private_adaptive_pool;namespace boost {
  template<typename T, typename SegmentManager, 
           std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, 
           unsigned char OverheadPercent = 5> 
    class private_adaptive_pool_v1;

  // Equality test for same type of private_adaptive_pool_base. 
  template<unsigned int V, typename T, typename S, std::size_t NodesPerBlock, 
           std::size_t F, unsigned char OP> 
    bool operator==(const private_adaptive_pool_base< V, T, S, NodesPerBlock, F, OP > & alloc1, 
                    const private_adaptive_pool_base< V, T, S, NodesPerBlock, F, OP > & alloc2);

  // Inequality test for same type of private_adaptive_pool_base. 
  template<unsigned int V, typename T, typename S, std::size_t NodesPerBlock, 
           std::size_t F, unsigned char OP> 
    bool operator!=(const private_adaptive_pool_base< V, T, S, NodesPerBlock, F, OP > & alloc1, 
                    const private_adaptive_pool_base< V, T, S, NodesPerBlock, F, OP > & alloc2);
  namespace interprocess {

    // Constructor from a segment manager. 
     private_adaptive_pool_base(segment_manager * segment_mngr);

    // Copy constructor from other private_adaptive_pool_base. Never throws. 
     private_adaptive_pool_base(const private_adaptive_pool_base & other);

    // Copy constructor from related private_adaptive_pool_base. Never throws. 
    template<typename T2> 
       private_adaptive_pool_base(const private_adaptive_pool_base< Version, T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent > & other);

    // Destructor, frees all used memory. Never throws. 
     ~private_adaptive_pool_base();
  }
}
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

template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
  class private_node_allocator;namespace boost {
  template<typename T, typename SegmentManager, 
           std::size_t NodesPerBlock = 64> 
    class private_node_allocator_v1;

  // Equality test for same type of private_node_allocator_base. 
  template<unsigned int V, typename T, typename S, std::size_t NPC> 
    bool operator==(const private_node_allocator_base< V, T, S, NPC > & alloc1, 
                    const private_node_allocator_base< V, T, S, NPC > & alloc2);

  // Inequality test for same type of private_node_allocator_base. 
  template<unsigned int V, typename T, typename S, std::size_t NPC> 
    bool operator!=(const private_node_allocator_base< V, T, S, NPC > & alloc1, 
                    const private_node_allocator_base< V, T, S, NPC > & alloc2);
  namespace interprocess {
    template<typename T2> struct rebind;

    typedef boost::intrusive::pointer_traits< void_pointer >::template rebind_pointer< T >::type pointer;
    typedef boost::intrusive::pointer_traits< void_pointer >::template rebind_pointer< const T >::type const_pointer;
    typedef T value_type;
    typedef unspecified reference;
    typedef unspecified const_reference;
    typedef segment_manager::size_type size_type;
    typedef segment_manager::difference_type difference_type;
    typedef boost::interprocess::version_type< private_node_allocator_base, Version > version;
    typedef unspecified multiallocation_chain;

    // Constructor from a segment manager. 
     private_node_allocator_base(segment_manager * segment_mngr);

    // Copy constructor from other private_node_allocator_base. Never throws. 
     private_node_allocator_base(const private_node_allocator_base & other);

    // Copy constructor from related private_node_allocator_base. Never throws. 
    template<typename T2> 
       private_node_allocator_base(const private_node_allocator_base< Version, T2, SegmentManager, NodesPerBlock > & other);

    // Destructor, frees all used memory. Never throws. 
     ~private_node_allocator_base();
    segment_manager * get_segment_manager();
    node_pool_t * get_node_pool();
    friend void swap(self_t &, self_t &);
  }
}
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator==(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, 
                  const private_node_allocator< T, S, NodesPerBlock, F, OP > &);
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator!=(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, 
                  const private_node_allocator< T, S, NodesPerBlock, F, OP > &);

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

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

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

Describes the error numbering of interprocess classes

namespace boost {
  namespace interprocess {

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

    typedef int native_error_t;
  }
}

Describes exceptions thrown by interprocess classes

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

Describes file_mapping and mapped region classes

namespace boost {
  namespace interprocess {
    class file_mapping;
    class remove_file_on_destroy;
  }
}

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

namespace boost {
  namespace interprocess {
    template<typename MapConfig> struct flat_map_index_aux;
  }
}

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

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

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

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

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

namespace boost {
  namespace interprocess {
    template<typename Mutex> class scoped_lock;
    template<typename SharableMutex> class sharable_lock;
    template<typename UpgradableMutex> class upgradable_lock;
    template<typename T, typename SegmentManager> class allocator;
    template<typename T, typename SegmentManager, 
             std::size_t NodesPerBlock = 64> 
      class node_allocator;
    template<typename T, typename SegmentManager, 
             std::size_t NodesPerBlock = 64> 
      class private_node_allocator;
    template<typename T, typename SegmentManager, 
             std::size_t NodesPerBlock = 64> 
      class cached_node_allocator;
    template<typename T, typename SegmentManager, 
             std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, 
             unsigned char OverheadPercent = 5> 
      class adaptive_pool;
    template<typename T, typename SegmentManager, 
             std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, 
             unsigned char OverheadPercent = 5> 
      class private_adaptive_pool;
    template<typename T, typename SegmentManager, 
             std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, 
             unsigned char OverheadPercent = 5> 
      class cached_adaptive_pool;
    template<typename T, typename DifferenceType = std::ptrdiff_t, 
             typename OffsetType = std::size_t, 
             std::size_t Alignment = offset_type_alignment> 
      class offset_ptr;
    template<typename MutexFamily, typename VoidMutex = offset_ptr<void> > 
      class simple_seq_fit;
    template<typename MutexFamily, typename VoidMutex = offset_ptr<void>, 
             std::size_t MemAlignment = 0> 
      class rbtree_best_fit;
    template<typename IndexConfig> class flat_map_index;
    template<typename IndexConfig> class iset_index;
    template<typename IndexConfig> class iunordered_set_index;
    template<typename IndexConfig> class map_index;
    template<typename IndexConfig> class null_index;
    template<typename IndexConfig> class unordered_map_index;
    template<typename CharType, typename MemoryAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_external_buffer;
    template<typename CharType, typename MemoryAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_shared_memory;
    template<typename CharType, typename MemoryAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_xsi_shared_memory;
    template<typename CharType, typename MemoryAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_heap_memory;
    template<typename CharType, typename MemoryAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_mapped_file;
    template<typename CharT, typename CharTraits = std::char_traits<CharT> > 
      class basic_bufferbuf;
    template<typename CharT, typename CharTraits = std::char_traits<CharT> > 
      class basic_ibufferstream;
    template<typename CharT, typename CharTraits = std::char_traits<CharT> > 
      class basic_obufferstream;
    template<typename CharT, typename CharTraits = std::char_traits<CharT> > 
      class basic_bufferstream;
    template<typename CharVector, 
             typename CharTraits = std::char_traits<typename CharVector::value_type> > 
      class basic_vectorbuf;
    template<typename CharVector, 
             typename CharTraits = std::char_traits<typename CharVector::value_type> > 
      class basic_ivectorstream;
    template<typename CharVector, 
             typename CharTraits = std::char_traits<typename CharVector::value_type> > 
      class basic_ovectorstream;
    template<typename CharVector, 
             typename CharTraits = std::char_traits<typename CharVector::value_type> > 
      class basic_vectorstream;
    template<typename T, typename Deleter> class scoped_ptr;
    template<typename T, typename VoidPointer> class intrusive_ptr;
    template<typename T, typename VoidAllocator, typename Deleter> 
      class shared_ptr;
    template<typename T, typename VoidAllocator, typename Deleter> 
      class weak_ptr;
    template<typename VoidPointer> class message_queue_t;

    typedef basic_managed_external_buffer< char,rbtree_best_fit< null_mutex_family >,iset_index > managed_external_buffer;
    typedef basic_managed_external_buffer< wchar_t,rbtree_best_fit< null_mutex_family >,iset_index > wmanaged_external_buffer;
    typedef basic_managed_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_shared_memory;
    typedef basic_managed_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_shared_memory;
    typedef basic_managed_windows_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_windows_shared_memory;
    typedef basic_managed_windows_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_windows_shared_memory;
    typedef basic_managed_xsi_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_xsi_shared_memory;
    typedef basic_managed_xsi_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_xsi_shared_memory;
    typedef basic_managed_shared_memory< char,rbtree_best_fit< mutex_family, void * >,iset_index > fixed_managed_shared_memory;
    typedef basic_managed_shared_memory< wchar_t,rbtree_best_fit< mutex_family, void * >,iset_index > wfixed_managed_shared_memory;
    typedef basic_managed_heap_memory< char,rbtree_best_fit< null_mutex_family >,iset_index > managed_heap_memory;
    typedef basic_managed_heap_memory< wchar_t,rbtree_best_fit< null_mutex_family >,iset_index > wmanaged_heap_memory;
    typedef basic_managed_mapped_file< char,rbtree_best_fit< mutex_family >,iset_index > managed_mapped_file;
    typedef basic_managed_mapped_file< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_mapped_file;
    typedef message_queue_t< offset_ptr< void > > message_queue;

    static const std::size_t offset_type_alignment;
  }
}

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

Describes a named user memory allocation user class.

Describes a named heap memory allocation user class.

namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_windows_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.

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

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

namespace boost {
  template<typename T> struct has_trivial_constructor;
  template<typename T> struct has_trivial_destructor;
  namespace interprocess {
    template<typename E, typename T, typename W, typename X, typename Y, 
             std::size_t Z> 
      std::basic_ostream< E, T > & 
      operator<<(std::basic_ostream< E, T > &, 
                 offset_ptr< W, X, Y, Z > const &);
    template<typename E, typename T, typename W, typename X, typename Y, 
             std::size_t Z> 
      std::basic_istream< E, T > & 
      operator>>(std::basic_istream< E, T > &, offset_ptr< W, X, Y, Z > &);

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

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

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

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

Describes permissions class

namespace boost {
  namespace interprocess {
    class permissions;
  }
}

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

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

Describes a shared memory object management class.

namespace boost {
  namespace interprocess {
    class shared_memory_object;
    class remove_shared_memory_on_destroy;
  }
}

Describes the functor to delete objects from the segment.

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

Describes an utility to form a shared pointer from this

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

Describes an intrusive ownership pointer.

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

Describes the smart pointer scoped_ptr

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

Describes the smart pointer shared_ptr

namespace boost {
  namespace interprocess {
    template<typename T, typename ManagedMemory> struct managed_shared_ptr;
    template<typename T, typename VoidAllocator, typename Deleter, typename U, 
             typename VoidAllocator2, typename Deleter2> 
      bool operator==(shared_ptr< T, VoidAllocator, Deleter > const & a, 
                      shared_ptr< U, VoidAllocator2, Deleter2 > const & b);
    template<typename T, typename VoidAllocator, typename Deleter, typename U, 
             typename VoidAllocator2, typename Deleter2> 
      bool operator!=(shared_ptr< T, VoidAllocator, Deleter > const & a, 
                      shared_ptr< U, VoidAllocator2, Deleter2 > const & b);
    template<typename T, typename VoidAllocator, typename Deleter, typename U, 
             typename VoidAllocator2, typename Deleter2> 
      bool operator<(shared_ptr< T, VoidAllocator, Deleter > const & a, 
                     shared_ptr< U, VoidAllocator2, Deleter2 > const & b);
    template<typename T, typename VoidAllocator, typename Deleter> 
      void swap(shared_ptr< T, VoidAllocator, Deleter > & a, 
                shared_ptr< T, VoidAllocator, Deleter > & b);
    template<typename T, typename VoidAllocator, typename Deleter, typename U> 
      shared_ptr< T, VoidAllocator, Deleter > 
      static_pointer_cast(shared_ptr< U, VoidAllocator, Deleter > const & r);
    template<typename T, typename VoidAllocator, typename Deleter, typename U> 
      shared_ptr< T, VoidAllocator, Deleter > 
      const_pointer_cast(shared_ptr< U, VoidAllocator, Deleter > const & r);
    template<typename T, typename VoidAllocator, typename Deleter, typename U> 
      shared_ptr< T, VoidAllocator, Deleter > 
      dynamic_pointer_cast(shared_ptr< U, VoidAllocator, Deleter > const & r);
    template<typename T, typename VoidAllocator, typename Deleter> 
      T * to_raw_pointer(shared_ptr< T, VoidAllocator, Deleter > const & p);
    template<typename E, typename T, typename Y, typename VoidAllocator, 
             typename Deleter> 
      std::basic_ostream< E, T > & 
      operator<<(std::basic_ostream< E, T > & os, 
                 shared_ptr< Y, VoidAllocator, Deleter > const & p);
    template<typename T, typename ManagedMemory> 
      managed_shared_ptr< T, ManagedMemory >::type 
      make_managed_shared_ptr(T *, ManagedMemory &);
    template<typename T, typename ManagedMemory> 
      managed_shared_ptr< T, ManagedMemory >::type 
      make_managed_shared_ptr(T *, ManagedMemory &, std::nothrow_t);
  }
}

Describes the smart pointer unique_ptr

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

    template<typename T, typename ManagedMemory> struct managed_unique_ptr;
    template<typename T, typename D> 
      void swap(unique_ptr< T, D > & x, unique_ptr< T, D > & y);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator==(const unique_ptr< T1, D1 > & x, 
                      const unique_ptr< T2, D2 > & y);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator!=(const unique_ptr< T1, D1 > & x, 
                      const unique_ptr< T2, D2 > & y);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator<(const unique_ptr< T1, D1 > & x, 
                     const unique_ptr< T2, D2 > & y);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator<=(const unique_ptr< T1, D1 > & x, 
                      const unique_ptr< T2, D2 > & y);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator>(const unique_ptr< T1, D1 > & x, 
                     const unique_ptr< T2, D2 > & y);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator>=(const unique_ptr< T1, D1 > & x, 
                      const unique_ptr< T2, D2 > & y);
    template<typename T, typename ManagedMemory> 
      managed_unique_ptr< T, ManagedMemory >::type 
      make_managed_unique_ptr(T *, ManagedMemory &);
  }
}

Describes the smart pointer weak_ptr.

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

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

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

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

Describes a class that wraps file locking capabilities.

namespace boost {
  namespace interprocess {
    class file_lock;
  }
}

Describes process-shared variables interprocess_condition class

namespace boost {
  namespace interprocess {
    class interprocess_condition;
  }
  namespace posix_time {
  }
}

Describes process-shared variables interprocess_condition_any class

namespace boost {
  namespace interprocess {
    class interprocess_condition_any;
  }
  namespace posix_time {
  }
}

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

namespace boost {
  namespace interprocess {
    class interprocess_mutex;
  }
}

Describes interprocess_recursive_mutex and shared_recursive_try_mutex classes

namespace boost {
  namespace interprocess {
    class interprocess_recursive_mutex;
  }
}

Describes a interprocess_semaphore class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class interprocess_semaphore;
  }
}

Describes interprocess_sharable_mutex class

namespace boost {
  namespace interprocess {
    class interprocess_sharable_mutex;
  }
}

Describes interprocess_upgradable_mutex class

namespace boost {
  namespace interprocess {
    class interprocess_upgradable_mutex;
  }
}

Describes the lock options with associated with interprocess_mutex lock constructors.

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

    static const defer_lock_type defer_lock;
    static const try_to_lock_type try_to_lock;
    static const accept_ownership_type accept_ownership;
  }
  namespace posix_time {
  }
}

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

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

Describes a named condition class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_condition;
  }
}

Describes a named condition class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_condition_any;
  }
}

Describes a named mutex class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_mutex;
  }
}

Describes a named named_recursive_mutex class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_recursive_mutex;
  }
}

Describes a named semaphore class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_semaphore;
  }
}

Describes a named sharable mutex class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_sharable_mutex;
  }
}

Describes a named upgradable mutex class for inter-process synchronization

namespace boost {
  namespace interprocess {
    class named_upgradable_mutex;
  }
}

Describes null_mutex classes

namespace boost {
  namespace interprocess {
    class null_mutex;
  }
  namespace posix_time {
  }
}

Describes the scoped_lock class.

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

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

Describes a class representing a native windows shared memory.

namespace boost {
  namespace interprocess {
    class windows_shared_memory;
  }
}

Describes a class representing a xsi key type.

namespace boost {
  namespace interprocess {
    class xsi_key;
  }
}

Describes a class representing a native xsi shared memory.

namespace boost {
  namespace interprocess {
    class xsi_shared_memory;
  }
}

PrevUpHomeNext