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

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

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

Describes adaptive_pool pooled shared memory STL compatible allocator

  
    template<typename T, typename SegmentManager,  NodesPerBlock, 
              MaxFreeBlocks,  OverheadPercent> 
      class adaptive_pool;
    template<typename T, typename S,  NodesPerBlock,  F, 
              OP> 
       (adaptive_pool< , 
                      adaptive_pool< );
    template<typename T, typename S,  NodesPerBlock,  F, 
              OP> 
       (adaptive_pool< , 
                      adaptive_pool< );
  }
}

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

  
    template<typename T, typename SegmentManager> class allocator;
    template<typename T, typename SegmentManager> 
       (allocator< , 
                      allocator< );
    template<typename T, typename SegmentManager> 
       (allocator< , 
                      allocator< );
  }
}

Describes cached_adaptive_pool pooled shared memory STL compatible allocator

  
    template<typename T, typename SegmentManager,  NodesPerBlock, 
              MaxFreeBlocks,  OverheadPercent> 
      class cached_adaptive_pool;
    template<typename T, typename S,  NodesPerBlock,  F, 
              OP> 
       (cached_adaptive_pool< , 
                      cached_adaptive_pool< );
    template<typename T, typename S,  NodesPerBlock,  F, 
              OP> 
       (cached_adaptive_pool< , 
                      cached_adaptive_pool< );
  }
}

Describes cached_cached_node_allocator pooled shared memory STL compatible allocator

  
    template<typename T, typename SegmentManager,  NodesPerBlock> 
      class cached_node_allocator;
    template<typename T, typename S,  NPC> 
       (cached_node_allocator< , 
                      cached_node_allocator< );
    template<typename T, typename S,  NPC> 
       (cached_node_allocator< , 
                      cached_node_allocator< );
  }
}

Describes node_allocator pooled shared memory STL compatible allocator

  
    template<typename T, typename SegmentManager,  NodesPerBlock> 
      class node_allocator;
    template<typename T, typename S,  NPC> 
       (node_allocator< , 
                      node_allocator< );
    template<typename T, typename S,  NPC> 
       (node_allocator< , 
                      node_allocator< );
  }
}

Describes private_adaptive_pool_base pooled shared memory STL compatible allocator

  
    template<typename T, typename SegmentManager,  NodesPerBlock, 
              MaxFreeBlocks,  OverheadPercent> 
      class private_adaptive_pool;
    template<typename T, typename S,  NodesPerBlock,  F, 
              OP> 
       (private_adaptive_pool< , 
                      private_adaptive_pool< );
    template<typename T, typename S,  NodesPerBlock,  F, 
              OP> 
       (private_adaptive_pool< , 
                      private_adaptive_pool< );
  }
}

Describes private_node_allocator_base pooled shared memory STL compatible allocator

  
    template<typename T, typename SegmentManager,  NodesPerBlock> 
      class private_node_allocator;
    template<typename T, typename S,  NodesPerBlock,  F, 
              OP> 
       (private_node_allocator< , 
                      private_node_allocator< );
    template<typename T, typename S,  NodesPerBlock,  F, 
              OP> 
       (private_node_allocator< , 
                      private_node_allocator< );
  }
}

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

  
    mapped_region (,  = );
  }
}

  
    struct create_only_t;
    struct open_copy_on_write_t;
    struct open_only_t;
    struct open_or_create_t;
    struct open_read_only_t;
    struct open_read_private_t;

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

Describes the error numbering of interprocess classes

  

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

    typedef  ;
  }
}

Describes exceptions thrown by interprocess classes

  
    class bad_alloc;
    class interprocess_exception;
    class lock_exception;
  }
}

Describes file_mapping and mapped region classes

  
    class file_mapping;
  }
}

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

  
    template<typename MapConfig> class flat_map_index;
  }
}

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

  
    template<typename MapConfig> class iset_index;
  }
}

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

  
    template<typename MapConfig> class iunordered_set_index;
  }
}

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

  
    template<typename MapConfig> class map_index;
  }
}

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

  
    template<typename MapConfig> class null_index;
  }
}

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

  
    template<typename MapConfig> class unordered_map_index;
  }
}

This header file forward declares the basic interprocess types:

The following synchronization mechanisms and locks:

The following mutex families:

The following allocators:

The following allocation algorithms:

The following index types:

The following managed memory types:

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.

  
    template<typename VoidPointer> class message_queue_t;

    enum mqblock_types { blocking, timed, non_blocking };
    typedef message_queue_t< offset_ptr<  ;
  }
}

Describes a named user memory allocation user class.

  
    template<typename CharType, typename AllocationAlgorithm, 
              IndexType> 
      class basic_managed_external_buffer;
    typedef basic_managed_external_buffer< rbtree_best_fit< null_mutex_family >,iset_index > ;
    typedef basic_managed_external_buffer< rbtree_best_fit< null_mutex_family >,iset_index > ;
  }
}

Describes a named heap memory allocation user class.

  
    template<typename CharType, typename AllocationAlgorithm, 
              IndexType> 
      class basic_managed_heap_memory;
    typedef basic_managed_heap_memory< rbtree_best_fit< null_mutex_family >,iset_index > ;
    typedef basic_managed_heap_memory< rbtree_best_fit< null_mutex_family >,iset_index > ;
  }
}

  
    template<typename CharType, typename AllocationAlgorithm, 
              IndexType> 
      class basic_managed_mapped_file;
    typedef basic_managed_mapped_file< rbtree_best_fit< mutex_family >,iset_index > ;
    typedef basic_managed_mapped_file< rbtree_best_fit< mutex_family >,iset_index > ;
  }
}

  
    template<typename CharType, typename AllocationAlgorithm, 
              IndexType> 
      class basic_managed_shared_memory;
    typedef basic_managed_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ;
    typedef basic_managed_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ;
    typedef basic_managed_shared_memory< rbtree_best_fit< mutex_family, iset_index > ;
    typedef basic_managed_shared_memory< rbtree_best_fit< mutex_family, iset_index > ;
  }
}

  
    template<typename CharType, typename AllocationAlgorithm, 
              IndexType> 
      class basic_managed_windows_shared_memory;
    typedef basic_managed_windows_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ;
    typedef basic_managed_windows_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ;
  }
}

  
    template<typename CharType, typename AllocationAlgorithm, 
              IndexType> 
      class basic_managed_xsi_shared_memory;
    typedef basic_managed_xsi_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ;
    typedef basic_managed_xsi_shared_memory< rbtree_best_fit< mutex_family >,iset_index > ;
  }
}

Describes mapped region class

  
    class mapped_region;
  }
}

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

  
    template<typename MutexFamily, typename VoidPointer, 
              MemAlignment> 
      class rbtree_best_fit;
  }
}

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

  
    template<typename MutexFamily, typename VoidPointer> class simple_seq_fit;
  }
}

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

  
    template<typename PointedType, typename DifferenceType, 
             typename OffsetType,  OffsetAlignment> 
      class offset_ptr;
    template<typename E, typename T, typename W, typename X, typename Y, 
              Z> 
       
      (, 
                 offset_ptr< );
    template<typename E, typename T, typename W, typename X, typename Y, 
              Z> 
       
      (, offset_ptr< );

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

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

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

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

Describes permissions class

  
    class permissions;
  }
}

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

  
    template<typename CharType, typename MemoryAlgorithm, 
              IndexType> 
      class segment_manager;
    template<typename MemoryAlgorithm> class segment_manager_base;
  }
}

Describes a shared memory object management class.

  
    class shared_memory_object;
  }
}

Describes the functor to delete objects from the segment.

  
    template<typename T, typename SegmentManager> class deleter;
  }
}

Describes an utility to form a shared pointer from this

  
    template<typename T, typename A, typename D> class enable_shared_from_this;
  }
}

Describes an intrusive ownership pointer.

  
    template<typename T, typename VoidPointer> class intrusive_ptr;
    template<typename T, typename U, typename VP> 
       (intrusive_ptr< , 
                      intrusive_ptr< );
    template<typename T, typename U, typename VP> 
       (intrusive_ptr< , 
                      intrusive_ptr< );
    template<typename T, typename VP> 
       (intrusive_ptr< , 
                      intrusive_ptr< );
    template<typename T, typename VP> 
       (intrusive_ptr< , 
                      intrusive_ptr< );
    template<typename T, typename VP> 
       (intrusive_ptr< , 
                      intrusive_ptr< );
    template<typename T, typename VP> 
       (intrusive_ptr< , 
                      intrusive_ptr< );
    template<typename T, typename VP> 
       (intrusive_ptr< , 
                     intrusive_ptr< );
    template<typename T, typename VP> 
       (intrusive_ptr< , intrusive_ptr< );
    template<typename E, typename T, typename Y, typename VP> 
       
      ( os, 
                 intrusive_ptr<  p);
    template<typename T, typename VP> 
      boost::interprocess::intrusive_ptr<  
      (intrusive_ptr< );
  }
}

Describes the smart pointer scoped_ptr

  
    template<typename T, typename Deleter> class scoped_ptr;
    template<typename T, typename D> 
       (scoped_ptr< , scoped_ptr< );
    template<typename T, typename D> 
      scoped_ptr<  (scoped_ptr< );
  }
}

Describes the smart pointer shared_ptr

  
    template<typename T, typename ManagedMemory> struct managed_shared_ptr;

    template<typename T, typename VoidAllocator, typename Deleter> 
      class shared_ptr;
    template<typename T, typename VoidAllocator, typename Deleter, typename U, 
             typename VoidAllocator2, typename Deleter2> 
       (shared_ptr<  a, 
                      shared_ptr<  b);
    template<typename T, typename VoidAllocator, typename Deleter, typename U, 
             typename VoidAllocator2, typename Deleter2> 
       (shared_ptr<  a, 
                      shared_ptr<  b);
    template<typename T, typename VoidAllocator, typename Deleter, typename U, 
             typename VoidAllocator2, typename Deleter2> 
       (shared_ptr<  a, 
                     shared_ptr<  b);
    template<typename T, typename VoidAllocator, typename Deleter> 
       (shared_ptr<  a, 
                shared_ptr<  b);
    template<typename T, typename VoidAllocator, typename Deleter, typename U> 
      shared_ptr<  
      (shared_ptr<  r);
    template<typename T, typename VoidAllocator, typename Deleter, typename U> 
      shared_ptr<  
      (shared_ptr<  r);
    template<typename T, typename VoidAllocator, typename Deleter, typename U> 
      shared_ptr<  
      (shared_ptr<  r);
    template<typename T, typename VoidAllocator, typename Deleter> 
       (shared_ptr<  p);
    template<typename E, typename T, typename Y, typename VoidAllocator, 
             typename Deleter> 
       
      ( os, 
                 shared_ptr<  p);
    template<typename T, typename ManagedMemory> 
      managed_shared_ptr<  
      (, );
    template<typename T, typename ManagedMemory> 
      managed_shared_ptr<  
      (, , );
  }
}

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

  
    template<typename T, typename ManagedMemory> struct managed_unique_ptr;
    template<typename T, typename ManagedMemory> 
      managed_unique_ptr<  
      (, );
  }
}

Describes the smart pointer weak_ptr.

  
    template<typename T, typename ManagedMemory> struct managed_weak_ptr;

    template<typename T, typename A, typename D> class weak_ptr;
    template<typename T, typename A, typename D, typename U, typename A2, 
             typename D2> 
       (weak_ptr<  a, 
                     weak_ptr<  b);
    template<typename T, typename A, typename D> 
       (weak_ptr<  a, weak_ptr<  b);
    template<typename T, typename ManagedMemory> 
      managed_weak_ptr<  
      (, );
  }
}

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

  
    template<typename CharT, typename CharTraits> class basic_bufferbuf;
    template<typename CharT, typename CharTraits> class basic_bufferstream;
    template<typename CharT, typename CharTraits> class basic_ibufferstream;
    template<typename CharT, typename CharTraits> class basic_obufferstream;

    typedef basic_bufferbuf<  ;
    typedef basic_bufferstream<  ;
    typedef basic_ibufferstream<  ;
    typedef basic_obufferstream<  ;
    typedef basic_bufferbuf<  ;
    typedef basic_bufferstream<  ;
    typedef basic_ibufferstream<  ;
    typedef basic_obufferstream<  ;
  }
}

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

  
    template<typename CharVector, typename CharTraits> 
      class basic_ivectorstream;
    template<typename CharVector, typename CharTraits> 
      class basic_ovectorstream;
    template<typename CharVector, typename CharTraits> class basic_vectorbuf;
    template<typename CharVector, typename CharTraits> class basic_vectorstream;
  }
}

  
     ();
  }
}

Describes a class that wraps file locking capabilities.

  
    class file_lock;
  }
}

Describes process-shared variables interprocess_condition class

  
    class interprocess_condition;
  }
}

Describes process-shared variables interprocess_condition_any class

  
    class interprocess_condition_any;
  }
}

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

  
    class interprocess_mutex;
  }
}

Describes interprocess_recursive_mutex and shared_recursive_try_mutex classes

  
    class interprocess_recursive_mutex;
  }
}

Describes a interprocess_semaphore class for inter-process synchronization

  
    class interprocess_semaphore;
  }
}

Describes interprocess_sharable_mutex class

  
    class interprocess_sharable_mutex;
  }
}

Describes interprocess_upgradable_mutex class

  
    class interprocess_upgradable_mutex;
  }
}

Describes the lock options with associated with interprocess_mutex lock constructors.

  
    struct accept_ownership_type;
    struct defer_lock_type;
    struct try_to_lock_type;

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

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

  
    struct mutex_family;
    struct null_mutex_family;
  }
}

Describes a named condition class for inter-process synchronization

  
    class named_condition;
  }
}

Describes a named condition class for inter-process synchronization

  
    class named_condition_any;
  }
}

Describes a named mutex class for inter-process synchronization

  
    class named_mutex;
  }
}

Describes a named named_recursive_mutex class for inter-process synchronization

  
    class named_recursive_mutex;
  }
}

Describes a named semaphore class for inter-process synchronization

  
    class named_semaphore;
  }
}

Describes a named sharable mutex class for inter-process synchronization

  
    class named_sharable_mutex;
  }
}

Describes a named upgradable mutex class for inter-process synchronization

  
    class named_upgradable_mutex;
  }
}

Describes null_mutex classes

  
    class null_mutex;
  }
}

Describes the scoped_lock class.

  
    template<typename Mutex> class scoped_lock;
  }
}

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

  
    template<typename SharableMutex> class sharable_lock;
  }
}

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

  
    template<typename UpgradableMutex> class upgradable_lock;
  }
}

Describes a class representing a native windows shared memory.

  
    class windows_shared_memory;
  }
}

Describes a class representing a xsi key type.

  
    class xsi_key;
  }
}

Describes a class representing a native xsi shared memory.

  
    class xsi_shared_memory;
  }
}