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

Boost C++ Libraries Home Libraries People FAQ More
PrevUpHomeNext

Boost.Interprocess Reference

Header <boost/interprocess/allocators/adaptive_pool.hpp>
Header <boost/interprocess/allocators/allocation_type.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/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/set.hpp>
Header <boost/interprocess/containers/slist.hpp>
Header <boost/interprocess/containers/string.hpp>
Header <boost/interprocess/containers/vector.hpp>
Header <boost/interprocess/creation_tags.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/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/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_barrier.hpp>
Header <boost/interprocess/sync/interprocess_condition.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_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_mutex.hpp>
Header <boost/interprocess/sync/named_recursive_mutex.hpp>
Header <boost/interprocess/sync/named_semaphore.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/allocators/adaptive_pool.hpp>

Describes adaptive_pool pooled shared memory STL compatible allocator 

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

Header <boost/interprocess/allocators/allocation_type.hpp>

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

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

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

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

Describes cached_adaptive_pool pooled shared memory STL compatible allocator 

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

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

Describes cached_cached_node_allocator pooled shared memory STL compatible allocator 

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

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

Describes node_allocator pooled shared memory STL compatible allocator 

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

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

Describes private_adaptive_pool_base pooled shared memory STL compatible allocator 

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

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

Describes private_node_allocator_base pooled shared memory STL compatible allocator 

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

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

namespace boost {
  namespace interprocess {
    template<typename T, typename Alloc> class deque;
    template<typename T, typename Alloc> 
      bool operator==(const deque< T, Alloc > & x, 
                      const deque< T, Alloc > & y);
    template<typename T, typename Alloc> 
      bool operator<(const deque< T, Alloc > & x, const deque< T, Alloc > & y);
    template<typename T, typename Alloc> 
      bool operator!=(const deque< T, Alloc > & x, 
                      const deque< T, Alloc > & y);
    template<typename T, typename Alloc> 
      bool operator>(const deque< T, Alloc > & x, const deque< T, Alloc > & y);
    template<typename T, typename Alloc> 
      bool operator<=(const deque< T, Alloc > & x, 
                      const deque< T, Alloc > & y);
    template<typename T, typename Alloc> 
      bool operator>=(const deque< T, Alloc > & x, 
                      const deque< T, Alloc > & y);
    template<typename T, typename Alloc> 
      void swap(deque< T, Alloc > & x, deque< T, Alloc > & y);
  }
}

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

namespace boost {
  namespace interprocess {
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator==(const flat_map< Key, T, Pred, Alloc > & x, 
                      const flat_map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator<(const flat_map< Key, T, Pred, Alloc > & x, 
                     const flat_map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator!=(const flat_map< Key, T, Pred, Alloc > & x, 
                      const flat_map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator>(const flat_map< Key, T, Pred, Alloc > & x, 
                     const flat_map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator<=(const flat_map< Key, T, Pred, Alloc > & x, 
                      const flat_map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator>=(const flat_map< Key, T, Pred, Alloc > & x, 
                      const flat_map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(flat_map< Key, T, Pred, Alloc > & x, 
                flat_map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(unspecified x, flat_map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(flat_map< Key, T, Pred, Alloc > & x, unspecified y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator==(const flat_multimap< Key, T, Pred, Alloc > & x, 
                      const flat_multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator<(const flat_multimap< Key, T, Pred, Alloc > & x, 
                     const flat_multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator!=(const flat_multimap< Key, T, Pred, Alloc > & x, 
                      const flat_multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator>(const flat_multimap< Key, T, Pred, Alloc > & x, 
                     const flat_multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator<=(const flat_multimap< Key, T, Pred, Alloc > & x, 
                      const flat_multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator>=(const flat_multimap< Key, T, Pred, Alloc > & x, 
                      const flat_multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(flat_multimap< Key, T, Pred, Alloc > & x, 
                flat_multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(unspecified x, flat_multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(flat_multimap< Key, T, Pred, Alloc > & x, unspecified y);
  }
}

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

namespace boost {
  namespace interprocess {
    template<typename T, typename Pred, typename Alloc> 
      bool operator==(const flat_set< T, Pred, Alloc > & x, 
                      const flat_set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator<(const flat_set< T, Pred, Alloc > & x, 
                     const flat_set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator!=(const flat_set< T, Pred, Alloc > & x, 
                      const flat_set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator>(const flat_set< T, Pred, Alloc > & x, 
                     const flat_set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator<=(const flat_set< T, Pred, Alloc > & x, 
                      const flat_set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator>=(const flat_set< T, Pred, Alloc > & x, 
                      const flat_set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(flat_set< T, Pred, Alloc > & x, 
                flat_set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(unspecified x, flat_set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(flat_set< T, Pred, Alloc > & x, unspecified y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator==(const flat_multiset< T, Pred, Alloc > & x, 
                      const flat_multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator<(const flat_multiset< T, Pred, Alloc > & x, 
                     const flat_multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator!=(const flat_multiset< T, Pred, Alloc > & x, 
                      const flat_multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator>(const flat_multiset< T, Pred, Alloc > & x, 
                     const flat_multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator<=(const flat_multiset< T, Pred, Alloc > & x, 
                      const flat_multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator>=(const flat_multiset< T, Pred, Alloc > & x, 
                      const flat_multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(flat_multiset< T, Pred, Alloc > & x, 
                flat_multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(unspecified x, flat_multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(flat_multiset< T, Pred, Alloc > & x, unspecified y);
  }
}

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

namespace boost {
  namespace interprocess {
    template<typename T, typename A> class list;
    template<typename T, typename A> 
      bool operator==(const list< T, A > & x, const list< T, A > & y);
    template<typename T, typename A> 
      bool operator<(const list< T, A > & x, const list< T, A > & y);
    template<typename T, typename A> 
      bool operator!=(const list< T, A > & x, const list< T, A > & y);
    template<typename T, typename A> 
      bool operator>(const list< T, A > & x, const list< T, A > & y);
    template<typename T, typename A> 
      bool operator<=(const list< T, A > & x, const list< T, A > & y);
    template<typename T, typename A> 
      bool operator>=(const list< T, A > & x, const list< T, A > & y);
    template<typename T, typename A> 
      void swap(list< T, A > & x, list< T, A > & y);
    template<typename T, typename A> 
      void swap(unspecified x, list< T, A > & y);
    template<typename T, typename A> 
      void swap(list< T, A > & x, unspecified y);
  }
}

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

namespace boost {
  namespace interprocess {
    template<typename Key, typename T, typename Pred, typename Alloc> class map;
    template<typename Key, typename T, typename Pred, typename Alloc> 
      class multimap;
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator==(const map< Key, T, Pred, Alloc > & x, 
                      const map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator<(const map< Key, T, Pred, Alloc > & x, 
                     const map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator!=(const map< Key, T, Pred, Alloc > & x, 
                      const map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator>(const map< Key, T, Pred, Alloc > & x, 
                     const map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator<=(const map< Key, T, Pred, Alloc > & x, 
                      const map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator>=(const map< Key, T, Pred, Alloc > & x, 
                      const map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(map< Key, T, Pred, Alloc > & x, 
                map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(unspecified x, map< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(map< Key, T, Pred, Alloc > & x, unspecified y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator==(const multimap< Key, T, Pred, Alloc > & x, 
                      const multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator<(const multimap< Key, T, Pred, Alloc > & x, 
                     const multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator!=(const multimap< Key, T, Pred, Alloc > & x, 
                      const multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator>(const multimap< Key, T, Pred, Alloc > & x, 
                     const multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator<=(const multimap< Key, T, Pred, Alloc > & x, 
                      const multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      bool operator>=(const multimap< Key, T, Pred, Alloc > & x, 
                      const multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(multimap< Key, T, Pred, Alloc > & x, 
                multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(unspecified x, multimap< Key, T, Pred, Alloc > & y);
    template<typename Key, typename T, typename Pred, typename Alloc> 
      void swap(multimap< Key, T, Pred, Alloc > & x, unspecified y);
  }
}

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

namespace boost {
  namespace interprocess {
    template<typename T, typename Pred, typename Alloc> 
      bool operator==(const set< T, Pred, Alloc > & x, 
                      const set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator<(const set< T, Pred, Alloc > & x, 
                     const set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator!=(const set< T, Pred, Alloc > & x, 
                      const set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator>(const set< T, Pred, Alloc > & x, 
                     const set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator<=(const set< T, Pred, Alloc > & x, 
                      const set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator>=(const set< T, Pred, Alloc > & x, 
                      const set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(set< T, Pred, Alloc > & x, set< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(set< T, Pred, Alloc > & x, unspecified y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(unspecified y, set< T, Pred, Alloc > & x);
    template<typename T, typename Pred, typename Alloc> 
      bool operator==(const multiset< T, Pred, Alloc > & x, 
                      const multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator<(const multiset< T, Pred, Alloc > & x, 
                     const multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator!=(const multiset< T, Pred, Alloc > & x, 
                      const multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator>(const multiset< T, Pred, Alloc > & x, 
                     const multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator<=(const multiset< T, Pred, Alloc > & x, 
                      const multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      bool operator>=(const multiset< T, Pred, Alloc > & x, 
                      const multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(multiset< T, Pred, Alloc > & x, 
                multiset< T, Pred, Alloc > & y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(multiset< T, Pred, Alloc > & x, unspecified y);
    template<typename T, typename Pred, typename Alloc> 
      void swap(unspecified y, multiset< T, Pred, Alloc > & x);
  }
}

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

namespace boost {
  namespace interprocess {
    template<typename T, typename A> class slist;
    template<typename T, typename A> 
      bool operator==(const slist< T, A > & x, const slist< T, A > & y);
    template<typename T, typename A> 
      bool operator<(const slist< T, A > & sL1, const slist< T, A > & sL2);
    template<typename T, typename A> 
      bool operator!=(const slist< T, A > & sL1, const slist< T, A > & sL2);
    template<typename T, typename A> 
      bool operator>(const slist< T, A > & sL1, const slist< T, A > & sL2);
    template<typename T, typename A> 
      bool operator<=(const slist< T, A > & sL1, const slist< T, A > & sL2);
    template<typename T, typename A> 
      bool operator>=(const slist< T, A > & sL1, const slist< T, A > & sL2);
    template<typename T, typename A> 
      void swap(slist< T, A > & x, slist< T, A > & y);
    template<typename T, typename A> 
      void swap(unspecified x, slist< T, A > & y);
    template<typename T, typename A> 
      void swap(slist< T, A > & x, unspecified y);
  }
}namespace std {
  template<typename T, typename A> 
    class insert_iterator<boost::interprocess::slist< T, A >>;
}

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

namespace boost {
  namespace interprocess {
    template<typename CharT, typename Traits, typename A> class basic_string;
    template<typename CharT, typename Traits, typename A> 
      basic_string< CharT, Traits, A > 
      operator+(const basic_string< CharT, Traits, A > & x, 
                const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      unspecified operator+(unspecified mx, 
                            const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      unspecified operator+(const basic_string< CharT, Traits, A > & x, 
                            unspecified my);
    template<typename CharT, typename Traits, typename A> 
      basic_string< CharT, Traits, A > 
      operator+(const CharT * s, const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      unspecified operator+(const CharT * s, unspecified my);
    template<typename CharT, typename Traits, typename A> 
      basic_string< CharT, Traits, A > 
      operator+(CharT c, const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      unspecified operator+(CharT c, unspecified my);
    template<typename CharT, typename Traits, typename A> 
      basic_string< CharT, Traits, A > 
      operator+(const basic_string< CharT, Traits, A > & x, const CharT * s);
    template<typename CharT, typename Traits, typename A> 
      unspecified operator+(unspecified mx, const CharT * s);
    template<typename CharT, typename Traits, typename A> 
      basic_string< CharT, Traits, A > 
      operator+(const basic_string< CharT, Traits, A > & x, const CharT c);
    template<typename CharT, typename Traits, typename A> 
      unspecified operator+(unspecified mx, const CharT c);
    template<typename CharT, typename Traits, typename A> 
      bool operator==(const basic_string< CharT, Traits, A > & x, 
                      const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator==(const CharT * s, 
                      const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator==(const basic_string< CharT, Traits, A > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename A> 
      bool operator!=(const basic_string< CharT, Traits, A > & x, 
                      const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator!=(const CharT * s, 
                      const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator!=(const basic_string< CharT, Traits, A > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename A> 
      bool operator<(const basic_string< CharT, Traits, A > & x, 
                     const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator<(const CharT * s, 
                     const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator<(const basic_string< CharT, Traits, A > & x, 
                     const CharT * s);
    template<typename CharT, typename Traits, typename A> 
      bool operator>(const basic_string< CharT, Traits, A > & x, 
                     const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator>(const CharT * s, 
                     const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator>(const basic_string< CharT, Traits, A > & x, 
                     const CharT * s);
    template<typename CharT, typename Traits, typename A> 
      bool operator<=(const basic_string< CharT, Traits, A > & x, 
                      const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator<=(const CharT * s, 
                      const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator<=(const basic_string< CharT, Traits, A > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename A> 
      bool operator>=(const basic_string< CharT, Traits, A > & x, 
                      const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator>=(const CharT * s, 
                      const basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      bool operator>=(const basic_string< CharT, Traits, A > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename A> 
      void swap(basic_string< CharT, Traits, A > & x, 
                basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      void swap(unspecified mx, basic_string< CharT, Traits, A > & y);
    template<typename CharT, typename Traits, typename A> 
      void swap(basic_string< CharT, Traits, A > & x, unspecified my);
    template<typename CharT, typename Traits, typename A> 
      std::basic_ostream< CharT, Traits > & 
      operator<<(std::basic_ostream< CharT, Traits > & os, 
                 const