| Home | Libraries | People | FAQ | More

## Boost.Interprocess Reference

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

Describes adaptive_pool pooled shared memory STL compatible allocator

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

### Header <boost/interprocess/allocators/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 NodesPerBlock,
                 std::size_t MaxFreeBlocks, unsigned char OverheadPercent>
          class cached_adaptive_pool;
        template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F,
                 std::size_t OP>
          bool operator==(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &,
                          const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
        template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F,
                 std::size_t OP>
          bool operator!=(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &,
                          const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
      }
    }

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

Describes cached_cached_node_allocator pooled shared memory STL compatible allocator

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

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

Describes node_allocator pooled shared memory STL compatible allocator

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

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

Describes private_adaptive_pool_base pooled shared memory STL compatible allocator

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

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

Describes private_node_allocator_base pooled shared memory STL compatible allocator

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

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

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

    namespace boost {
      namespace interprocess {
        unspecified anonymous_shared_memory(std::size_t, void * = 0);
      }
    }

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

    BOOST_PP_LOCAL_MACRO(n)
    BOOST_PP_LOCAL_LIMITS

    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>

    BOOST_PP_LOCAL_MACRO(n)
    BOOST_PP_LOCAL_LIMITS

    namespace boost {
      namespace interprocess {
        template<typename Key, typename T, typename Pred, typename Alloc>
          class flat_map;
        template<typename Key, typename T, typename Pred, typename Alloc>
          class flat_multimap;
        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>

    BOOST_PP_LOCAL_MACRO(n)
    BOOST_PP_LOCAL_LIMITS

    namespace boost {
      namespace interprocess {
        template<typename T, typename Pred, typename Alloc> class flat_set;
        template<typename T, typename Pred, typename Alloc> class flat_multiset;
        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>

    BOOST_PP_LOCAL_MACRO(n)
    BOOST_PP_LOCAL_LIMITS

    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>

    BOOST_PP_LOCAL_MACRO(n)
    BOOST_PP_LOCAL_LIMITS

    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>

    BOOST_PP_LOCAL_MACRO(n)
    BOOST_PP_LOCAL_LIMITS

    namespace boost {
      namespace interprocess {
        template<typename T, typename Pred, typename Alloc> class set;
        template<typename T, typename Pred, typename Alloc> class multiset;
        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>

    BOOST_PP_LOCAL_MACRO(n)
    BOOST_PP_LOCAL_LIMITS

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

### 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 basic_string< CharT, Traits, A > & s);
        template<typename CharT, typename Traits, typename A>
          std::basic_ostream< CharT, Traits > &
          operator<<(std::basic_ostream< CharT, Traits > & os, unspecified ms);
        template<typename CharT, typename Traits, typename A>
          std::basic_istream< CharT, Traits > &
          operator>>(std::basic_istream< CharT, Traits > & is,
                     basic_string< CharT, Traits, A > & s);
        template<typename CharT, typename Traits, typename A>
          std::basic_istream< CharT, Traits > &
          operator>>(std::basic_istream< CharT, Traits > & is, unspecified ms);
        template<typename CharT, typename Traits, typename A>
          std::basic_istream< CharT, Traits > &
          getline(std::istream & is, basic_string< CharT, Traits, A > & s,
                  CharT delim);
        template<typename CharT, typename Traits, typename A>
          std::basic_istream< CharT, Traits > &
          getline(std::istream & is, unspecified ms, CharT delim);
        template<typename CharT, typename Traits, typename A>
          std::basic_istream< CharT, Traits > &
          getline(std::basic_istream< CharT, Traits > & is,
                  basic_string< CharT, Traits, A > & s);
        template<typename CharT, typename Traits, typename A>
          std::basic_istream< CharT, Traits > &
          getline(std::istream & is, unspecified ms);
        template<typename Ch, typename A>
          std::size_t hash_value(basic_string< Ch, std::char_traits< Ch >, A > const & v);
      }
    }

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

    BOOST_PP_LOCAL_MACRO(n)
    BOOST_PP_LOCAL_LIMITS

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

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

    namespace boost {
      namespace interprocess {
        struct create_only_t;
        struct open_only_t;
        struct open_read_only_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;
      }
    }

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

Describes the error numbering of interprocess classes

    namespace boost {
      namespace interprocess {

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

        typedef int native_error_t;
      }
    }

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

Describes exceptions thrown by interprocess classes

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

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

Describes file_mapping and mapped region classes

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

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

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

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

        template<typename MapConfig> class flat_map_index;
      }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    namespace boost {
      namespace interprocess {
        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_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 basic_string< char,std::char_traits< char >,std::allocator< char > > string;
      }
    }

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

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

    namespace boost {
      namespace interprocess {
        class message_queue;
      }
    }

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

Describes a named user memory allocation user class.

    namespace boost {
      namespace interprocess {
        template<typename CharType, typename AllocationAlgorithm,
                 template< class IndexConfig > class IndexType>
          class basic_managed_external_buffer;
      }
    }

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

Describes a named heap memory allocation user class.

    namespace boost {
      namespace interprocess {
        template<typename CharType, typename AllocationAlgorithm,
                 template< class IndexConfig > class IndexType>
          class basic_managed_heap_memory;
      }
    }

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

    namespace boost {
      namespace interprocess {
        template<typename CharType, typename AllocationAlgorithm,
                 template< class IndexConfig > class IndexType>
          class basic_managed_mapped_file;
      }
    }

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

    namespace boost {
      namespace interprocess {
        template<typename CharType, typename AllocationAlgorithm,
                 template< class IndexConfig > class IndexType>
          class basic_managed_shared_memory;
      }
    }

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

    namespace boost {
      namespace interprocess {
        template<typename CharType, typename AllocationAlgorithm,
                 template< class IndexConfig > class IndexType>
          class basic_managed_windows_shared_memory;
      }
    }

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

Describes memory_mappable and mapped region classes

    namespace boost {
      namespace interprocess {
        class mapped_region;
      }
    }

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

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

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

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

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

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

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

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

    namespace boost {
      namespace interprocess {
        template<typename PointedType> class offset_ptr;
        template<typename T1, typename T2>
          bool operator==(const offset_ptr< T1 > &, const offset_ptr< T2 > &);
        template<typename T1, typename T2>
          bool operator!=(const offset_ptr< T1 > &, const offset_ptr< T2 > &);
        template<typename T1, typename T2>
          bool operator<(const offset_ptr< T1 > &, const offset_ptr< T2 > &);
        template<typename T1, typename T2>
          bool operator<=(const offset_ptr< T1 > &, const offset_ptr< T2 > &);
        template<typename T1, typename T2>
          bool operator>(const offset_ptr< T1 > &, const offset_ptr< T2 > &);
        template<typename T1, typename T2>
          bool operator>=(const offset_ptr< T1 > &, const offset_ptr< T2 > &);
        template<typename E, typename T, typename Y>
          std::basic_ostream< E, T > &
          operator<<(std::basic_ostream< E, T > &, offset_ptr< Y > const &);
        template<typename E, typename T, typename Y>
          std::basic_istream< E, T > &
          operator>>(std::basic_istream< E, T > &, offset_ptr< Y > &);
        template<typename T>
          offset_ptr< T > operator+(std::ptrdiff_t, const offset_ptr< T > &);
        template<typename T, typename T2>
          std::ptrdiff_t
          operator-(const offset_ptr< T > &, const offset_ptr< T2 > &);
        template<typename T>
          void swap(boost::interprocess::offset_ptr< T > &,
                    boost::interprocess::offset_ptr< T > &);

        // Simulation of static_cast between pointers. Never throws.
        template<typename T, typename U>
          boost::interprocess::offset_ptr< T >
          static_pointer_cast(boost::interprocess::offset_ptr< U > const & r);

        // Simulation of const_cast between pointers. Never throws.
        template<typename T, typename U>
          boost::interprocess::offset_ptr< T >
          const_pointer_cast(boost::interprocess::offset_ptr< U > const & r);

        // Simulation of dynamic_cast between pointers. Never throws.
        template<typename T, typename U>
          boost::interprocess::offset_ptr< T >
          dynamic_pointer_cast(boost::interprocess::offset_ptr< U > const & r);

        // Simulation of reinterpret_cast between pointers. Never throws.
        template<typename T, typename U>
          boost::interprocess::offset_ptr< T >
          reinterpret_pointer_cast(boost::interprocess::offset_ptr< U > const & r);
      }
    }

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

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

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

        static unspecified anonymous_instance;
        static unspecified unique_instance;
      }
    }

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

Describes a shared memory object management class.

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

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

Describes the functor to delete objects from the segment.

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

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

Describes an utility to form a shared pointer from this

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

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

Describes an intrusive ownership pointer.

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

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

Describes the smart pointer scoped_ptr

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

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

Describes the smart pointer shared_ptr

    namespace boost {
      namespace interprocess {
        template<typename T, typename VoidAllocator, typename Deleter>
          class shared_ptr;

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

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

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>
          unspecified make_managed_unique_ptr(T *, ManagedMemory &);
      }
    }

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

Describes the smart pointer weak_ptr.

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

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

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

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

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

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

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

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

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

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

Describes a class that wraps file locking capabilities.

    namespace boost {
      namespace interprocess {
        class file_lock;
      }
    }

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

    BOOST_INTERPROCESS_USE_GENERIC_EMULATION

    namespace boost {
      namespace interprocess {
        class barrier;
      }
    }

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

Describes process-shared variables interprocess_condition class

    BOOST_INTERPROCESS_USE_GENERIC_EMULATION

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

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

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

    BOOST_INTERPROCESS_USE_GENERIC_EMULATION

    namespace boost {
      namespace interprocess {
        class interprocess_mutex;
      }
    }

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

Describes interprocess_recursive_mutex and shared_recursive_try_mutex classes

    BOOST_INTERPROCESS_USE_GENERIC_EMULATION

    namespace boost {
      namespace interprocess {
        class interprocess_recursive_mutex;
      }
    }

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

Describes a interprocess_semaphore class for inter-process synchronization

    BOOST_INTERPROCESS_USE_GENERIC_EMULATION

    namespace boost {
      namespace interprocess {
        class interprocess_semaphore;
      }
    }

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

Describes interprocess_upgradable_mutex class

    namespace boost {
      namespace interprocess {
        class interprocess_upgradable_mutex;
      }
    }

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

Describes the lock options with associated with interprocess_mutex lock constructors.

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

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

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

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

Describes process-shared variables interprocess_condition class

    namespace boost {
      namespace interprocess {
        class named_condition;
      }
    }

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

Describes a named mutex class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_mutex;
      }
    }

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

Describes a named named_recursive_mutex class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_recursive_mutex;
      }
    }

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

Describes a named semaphore class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_semaphore;
      }
    }

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

Describes a named upgradable mutex class for inter-process synchronization

    namespace boost {
      namespace interprocess {
        class named_upgradable_mutex;
      }
    }

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

Describes null_mutex classes

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

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

Describes the scoped_lock class.

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

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

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

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

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

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

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

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

Describes a class representing a native windows shared memory.

    namespace boost {
      namespace interprocess {
        class windows_shared_memory;
      }
    }