| Home | Libraries | People | FAQ | More

## Reference

### Header <boost/intrusive/any_hook.hpp>

    namespace boost {
      namespace intrusive {
        template<class... Options> class any_base_hook;
        template<class... Options> class any_member_hook;

        template<typename BasicHook> struct any_to_avl_set_hook;
        template<typename BasicHook> struct any_to_bs_set_hook;
        template<typename BasicHook> struct any_to_list_hook;
        template<typename BasicHook> struct any_to_set_hook;
        template<typename BasicHook> struct any_to_slist_hook;
        template<typename BasicHook> struct any_to_unordered_set_hook;
        template<class... Options> struct make_any_base_hook;
        template<class... Options> struct make_any_member_hook;
      }
    }

### Header <boost/intrusive/avl_set.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> class avl_multiset;
        template<typename T, class... Options> class avl_set;

        template<typename T, class... Options> struct make_avl_multiset;
        template<typename T, class... Options> struct make_avl_set;
        template<typename T, class... Options>
          bool operator!=(const avl_set< T, Options...> & x,
                          const avl_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const avl_set< T, Options...> & x,
                         const avl_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const avl_set< T, Options...> & x,
                          const avl_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const avl_set< T, Options...> & x,
                          const avl_set< T, Options...> & y);
        template<typename T, class... Options>
          void swap(avl_set< T, Options...> & x, avl_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const avl_multiset< T, Options...> & x,
                          const avl_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const avl_multiset< T, Options...> & x,
                         const avl_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const avl_multiset< T, Options...> & x,
                          const avl_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const avl_multiset< T, Options...> & x,
                          const avl_multiset< T, Options...> & y);
        template<typename T, class... Options>
          void swap(avl_multiset< T, Options...> & x,
                    avl_multiset< T, Options...> & y);
      }
    }

### Header <boost/intrusive/avl_set_hook.hpp>

    namespace boost {
      namespace intrusive {
        template<class... Options> class avl_set_base_hook;
        template<class... Options> class avl_set_member_hook;

        template<class... Options> struct make_avl_set_base_hook;
        template<class... Options> struct make_avl_set_member_hook;
      }
    }

### Header <boost/intrusive/avltree.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> class avltree;

        template<typename T, class... Options> struct make_avltree;
        template<typename T, class... Options>
          bool operator<(const avltree< T, Options...> & x,
                         const avltree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator==(const avltree< T, Options...> & x,
                          const avltree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const avltree< T, Options...> & x,
                          const avltree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const avltree< T, Options...> & x,
                         const avltree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const avltree< T, Options...> & x,
                          const avltree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const avltree< T, Options...> & x,
                          const avltree< T, Options...> & y);
        template<typename T, class... Options>
          void swap(avltree< T, Options...> & x, avltree< T, Options...> & y);
      }
    }

### Header <boost/intrusive/avltree_algorithms.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits> class avltree_algorithms;
      }
    }

### Header <boost/intrusive/bs_set.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> class bs_multiset;
        template<typename T, class... Options> class bs_set;

        template<typename T, class... Options> struct make_bs_multiset;
        template<typename T, class... Options> struct make_bs_set;
        template<typename T, class... Options>
          bool operator!=(const bs_set< T, Options...> & x,
                          const bs_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const bs_set< T, Options...> & x,
                         const bs_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const bs_set< T, Options...> & x,
                          const bs_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const bs_set< T, Options...> & x,
                          const bs_set< T, Options...> & y);
        template<typename T, class... Options>
          void swap(bs_set< T, Options...> & x, bs_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const bs_multiset< T, Options...> & x,
                          const bs_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const bs_multiset< T, Options...> & x,
                         const bs_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const bs_multiset< T, Options...> & x,
                          const bs_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const bs_multiset< T, Options...> & x,
                          const bs_multiset< T, Options...> & y);
        template<typename T, class... Options>
          void swap(bs_multiset< T, Options...> & x,
                    bs_multiset< T, Options...> & y);
      }
    }

### Header <boost/intrusive/bs_set_hook.hpp>

    namespace boost {
      namespace intrusive {
        template<class... Options> class bs_set_base_hook;
        template<class... Options> class bs_set_member_hook;

        template<class... Options> struct make_bs_set_base_hook;
        template<class... Options> struct make_bs_set_member_hook;
      }
    }

### Header <boost/intrusive/bstree.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> class bstree;

        template<typename T, class... Options> struct make_bstree;
        template<typename T, class... Options>
          bool operator<(const bstree< T, Options...> & x,
                         const bstree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator==(const bstree< T, Options...> & x,
                          const bstree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const bstree< T, Options...> & x,
                          const bstree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const bstree< T, Options...> & x,
                         const bstree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const bstree< T, Options...> & x,
                          const bstree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const bstree< T, Options...> & x,
                          const bstree< T, Options...> & y);
        template<typename T, class... Options>
          void swap(bstree< T, Options...> & x, bstree< T, Options...> & y);
      }
    }

### Header <boost/intrusive/bstree_algorithms.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits> class bstree_algorithms;
      }
    }

### Header <boost/intrusive/circular_list_algorithms.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits> class circular_list_algorithms;
      }
    }

### Header <boost/intrusive/circular_slist_algorithms.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits> class circular_slist_algorithms;
      }
    }

### Header <boost/intrusive/derivation_value_traits.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, typename NodeTraits,
                 link_mode_type LinkMode = safe_link>
          struct derivation_value_traits;
      }
    }

### Header <boost/intrusive/hashtable.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> class hashtable;

        template<typename T, class... Options> struct make_hashtable;
      }
    }

### Header <boost/intrusive/intrusive_fwd.hpp>

This header file forward declares most Intrusive classes.

It forward declares the following containers and hooks:

- boost::intrusive::slist / boost::intrusive::slist_base_hook / boost::intrusive::slist_member_hook

- boost::intrusive::list / boost::intrusive::list_base_hook / boost::intrusive::list_member_hook

- boost::intrusive::bstree / boost::intrusive::bs_set / boost::intrusive::bs_multiset / boost::intrusive::bs_set_base_hook / boost::intrusive::bs_set_member_hook

- boost::intrusive::rbtree / boost::intrusive::set / boost::intrusive::multiset / boost::intrusive::set_base_hook / boost::intrusive::set_member_hook

- boost::intrusive::avltree / boost::intrusive::avl_set / boost::intrusive::avl_multiset / boost::intrusive::avl_set_base_hook / boost::intrusive::avl_set_member_hook

- boost::intrusive::splaytree / boost::intrusive::splay_set / boost::intrusive::splay_multiset

- boost::intrusive::sgtree / boost::intrusive::sg_set / boost::intrusive::sg_multiset

- boost::intrusive::treap / boost::intrusive::treap_set / boost::intrusive::treap_multiset

- boost::intrusive::hashtable / boost::intrusive::unordered_set / boost::intrusive::unordered_multiset / boost::intrusive::unordered_set_base_hook / boost::intrusive::unordered_set_member_hook /

- boost::intrusive::any_base_hook / boost::intrusive::any_member_hook

It forward declares the following container or hook options:

- boost::intrusive::constant_time_size / boost::intrusive::size_type / boost::intrusive::compare / boost::intrusive::equal

- boost::intrusive::floating_point / boost::intrusive::priority / boost::intrusive::hash

- boost::intrusive::value_traits / boost::intrusive::member_hook / boost::intrusive::function_hook / boost::intrusive::base_hook

- boost::intrusive::void_pointer / boost::intrusive::tag / boost::intrusive::link_mode

- boost::intrusive::optimize_size / boost::intrusive::linear / boost::intrusive::cache_last

- boost::intrusive::bucket_traits / boost::intrusive::store_hash / boost::intrusive::optimize_multikey

- boost::intrusive::power_2_buckets / boost::intrusive::cache_begin / boost::intrusive::compare_hash / boost::intrusive::incremental

It forward declares the following value traits utilities:

- boost::intrusive::value_traits / boost::intrusive::derivation_value_traits / boost::intrusive::trivial_value_traits

Finally it forward declares the following general purpose utilities:

- boost::intrusive::pointer_plus_bits / boost::intrusive::priority_compare.

### Header <boost/intrusive/linear_slist_algorithms.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits> class linear_slist_algorithms;
      }
    }

### Header <boost/intrusive/link_mode.hpp>

    namespace boost {
      namespace intrusive {
        enum link_mode_type;
      }
    }

### Header <boost/intrusive/list.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> class list;

        template<typename T, class... Options> struct make_list;
        template<typename T, class... Options>
          bool operator<(const list< T, Options...> & x,
                         const list< T, Options...> & y);
        template<typename T, class... Options>
          bool operator==(const list< T, Options...> & x,
                          const list< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const list< T, Options...> & x,
                          const list< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const list< T, Options...> & x,
                         const list< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const list< T, Options...> & x,
                          const list< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const list< T, Options...> & x,
                          const list< T, Options...> & y);
        template<typename T, class... Options>
          void swap(list< T, Options...> & x, list< T, Options...> & y);
      }
    }

### Header <boost/intrusive/list_hook.hpp>

    namespace boost {
      namespace intrusive {
        template<class... Options> class list_base_hook;
        template<class... Options> class list_member_hook;

        template<class... Options> struct make_list_base_hook;
        template<class... Options> struct make_list_member_hook;
      }
    }

### Header <boost/intrusive/member_value_traits.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, typename NodeTraits,
                 typename NodeTraits::node T::* PtrToMember,
                 link_mode_type LinkMode = safe_link>
          struct member_value_traits;
      }
    }

### Header <boost/intrusive/options.hpp>

    namespace boost {
      namespace intrusive {
        template<typename BaseHook> struct base_hook;
        template<typename BucketTraits> struct bucket_traits;
        template<bool Enabled> struct cache_begin;
        template<bool Enabled> struct cache_last;
        template<typename Compare> struct compare;
        template<bool Enabled> struct compare_hash;
        template<bool Enabled> struct constant_time_size;
        template<typename Equal> struct equal;
        template<bool Enabled> struct floating_point;
        template<typename Functor> struct function_hook;
        template<typename Hash> struct hash;
        template<typename HeaderHolder> struct header_holder_type;
        template<bool Enabled> struct incremental;
        template<bool Enabled> struct linear;
        template<link_mode_type LinkType> struct link_mode;
        template<typename Parent, typename MemberHook,
                 MemberHook Parent::* PtrToMember>
          struct member_hook;
        template<bool Enabled> struct optimize_multikey;
        template<bool Enabled> struct optimize_size;
        template<bool Enabled> struct power_2_buckets;
        template<typename Priority> struct priority;
        template<typename SizeType> struct size_type;
        template<bool Enabled> struct store_hash;
        template<typename Tag> struct tag;
        template<typename ValueTraits> struct value_traits;
        template<typename VoidPointer> struct void_pointer;
      }
    }

### Header <boost/intrusive/pack_options.hpp>

    BOOST_INTRUSIVE_OPTION_TYPE(OPTION_NAME, TYPE, TYPEDEF_EXPR, TYPEDEF_NAME)
    BOOST_INTRUSIVE_OPTION_CONSTANT(OPTION_NAME, TYPE, VALUE, CONSTANT_NAME)

    namespace boost {
      namespace intrusive {
        template<typename DefaultOptions, class... Options> struct pack_options;
      }
    }

### Header <boost/intrusive/parent_from_member.hpp>

    namespace boost {
      namespace intrusive {
        template<typename Parent, typename Member>
          Parent * get_parent_from_member(Member *, const Member Parent::*);
        template<typename Parent, typename Member>
          const Parent *
          get_parent_from_member(const Member *, const Member Parent::*);
      }
    }

### Header <boost/intrusive/pointer_plus_bits.hpp>

    namespace boost {
      namespace intrusive {
        template<typename VoidPointer, std::size_t Alignment>
          struct max_pointer_plus_bits;

        template<std::size_t Alignment>
          struct max_pointer_plus_bits<void *, Alignment>;

        template<typename Pointer, std::size_t NumBits> struct pointer_plus_bits;

        template<typename T, std::size_t NumBits>
          struct pointer_plus_bits<T *, NumBits>;
      }
    }

### Header <boost/intrusive/pointer_rebind.hpp>

    namespace boost {
      namespace intrusive {
        template<typename Ptr, typename U> struct pointer_has_rebind;
        template<typename Ptr, typename U> struct pointer_has_rebind_other;
        template<typename Ptr, typename U> struct pointer_rebind;

        template<typename T, typename U> struct pointer_rebind<T *, U>;

        template<typename Ptr, typename U> struct pointer_rebind_mode;
        template<typename Ptr, typename U, unsigned int RebindMode>
          struct pointer_rebinder;

        template<typename Ptr, typename U> struct pointer_rebinder<Ptr, U, 1u>;
        template<typename Ptr, typename U> struct pointer_rebinder<Ptr, U, 2u>;
        template<template< class > class Ptr, typename A, typename U>
          struct pointer_rebinder<Ptr< A >, U, 0u>;
        template<template< class, class...> class Ptr, typename A, class... An,
                 typename U>
          struct pointer_rebinder<Ptr< A, An...>, U, 0u>;
      }
    }

### Header <boost/intrusive/pointer_traits.hpp>

    namespace boost {
      namespace intrusive {
        template<typename Ptr> struct pointer_traits;

        template<typename T> struct pointer_traits<T *>;
      }
    }

### Header <boost/intrusive/priority_compare.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T> struct priority_compare;
      }
    }

### Header <boost/intrusive/rbtree.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_rbtree;

        template<typename T, class... Options> class rbtree;
        template<typename T, class... Options>
          bool operator<(const rbtree< T, Options...> & x,
                         const rbtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator==(const rbtree< T, Options...> & x,
                          const rbtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const rbtree< T, Options...> & x,
                          const rbtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const rbtree< T, Options...> & x,
                         const rbtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const rbtree< T, Options...> & x,
                          const rbtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const rbtree< T, Options...> & x,
                          const rbtree< T, Options...> & y);
        template<typename T, class... Options>
          void swap(rbtree< T, Options...> & x, rbtree< T, Options...> & y);
      }
    }

### Header <boost/intrusive/rbtree_algorithms.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits> class rbtree_algorithms;
      }
    }

### Header <boost/intrusive/set.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_multiset;
        template<typename T, class... Options> struct make_set;

        template<typename T, class... Options> class multiset;
        template<typename T, class... Options> class set;
        template<typename T, class... Options>
          bool operator!=(const set< T, Options...> & x,
                          const set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const set< T, Options...> & x,
                         const set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const set< T, Options...> & x,
                          const set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const set< T, Options...> & x,
                          const set< T, Options...> & y);
        template<typename T, class... Options>
          void swap(set< T, Options...> & x, set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const multiset< T, Options...> & x,
                          const multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const multiset< T, Options...> & x,
                         const multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const multiset< T, Options...> & x,
                          const multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const multiset< T, Options...> & x,
                          const multiset< T, Options...> & y);
        template<typename T, class... Options>
          void swap(multiset< T, Options...> & x, multiset< T, Options...> & y);
      }
    }

### Header <boost/intrusive/set_hook.hpp>

    namespace boost {
      namespace intrusive {
        template<class... Options> struct make_set_base_hook;
        template<class... Options> struct make_set_member_hook;

        template<class... Options> class set_base_hook;
        template<class... Options> class set_member_hook;
      }
    }

### Header <boost/intrusive/sg_set.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_sg_multiset;
        template<typename T, class... Options> struct make_sg_set;

        template<typename T, class... Options> class sg_multiset;
        template<typename T, class... Options> class sg_set;
        template<typename T, class... Options>
          bool operator!=(const sg_set< T, Options...> & x,
                          const sg_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const sg_set< T, Options...> & x,
                         const sg_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const sg_set< T, Options...> & x,
                          const sg_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const sg_set< T, Options...> & x,
                          const sg_set< T, Options...> & y);
        template<typename T, class... Options>
          void swap(sg_set< T, Options...> & x, sg_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const sg_multiset< T, Options...> & x,
                          const sg_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const sg_multiset< T, Options...> & x,
                         const sg_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const sg_multiset< T, Options...> & x,
                          const sg_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const sg_multiset< T, Options...> & x,
                          const sg_multiset< T, Options...> & y);
        template<typename T, class... Options>
          void swap(sg_multiset< T, Options...> & x,
                    sg_multiset< T, Options...> & y);
      }
    }

### Header <boost/intrusive/sgtree.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_sgtree;

        template<typename T, class... Options> class sgtree;
        template<typename T, class... Options>
          bool operator<(const sgtree< T, Options...> & x,
                         const sgtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator==(const sgtree< T, Options...> & x,
                          const sgtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const sgtree< T, Options...> & x,
                          const sgtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const sgtree< T, Options...> & x,
                         const sgtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const sgtree< T, Options...> & x,
                          const sgtree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const sgtree< T, Options...> & x,
                          const sgtree< T, Options...> & y);
        template<typename T, class... Options>
          void swap(sgtree< T, Options...> & x, sgtree< T, Options...> & y);
      }
    }

### Header <boost/intrusive/sgtree_algorithms.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits> class sgtree_algorithms;
      }
    }

### Header <boost/intrusive/slist.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_slist;

        template<typename T, class... Options> class slist;
        template<typename T, class... Options>
          bool operator<(const slist< T, Options...> & x,
                         const slist< T, Options...> & y);
        template<typename T, class... Options>
          bool operator==(const slist< T, Options...> & x,
                          const slist< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const slist< T, Options...> & x,
                          const slist< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const slist< T, Options...> & x,
                         const slist< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const slist< T, Options...> & x,
                          const slist< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const slist< T, Options...> & x,
                          const slist< T, Options...> & y);
        template<typename T, class... Options>
          void swap(slist< T, Options...> & x, slist< T, Options...> & y);
      }
    }

### Header <boost/intrusive/slist_hook.hpp>

    namespace boost {
      namespace intrusive {
        template<class... Options> struct make_slist_base_hook;
        template<class... Options> struct make_slist_member_hook;

        template<class... Options> class slist_base_hook;
        template<class... Options> class slist_member_hook;
      }
    }

### Header <boost/intrusive/splay_set.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_splay_multiset;
        template<typename T, class... Options> struct make_splay_set;

        template<typename T, class... Options> class splay_multiset;
        template<typename T, class... Options> class splay_set;
        template<typename T, class... Options>
          bool operator!=(const splay_set< T, Options...> & x,
                          const splay_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const splay_set< T, Options...> & x,
                         const splay_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const splay_set< T, Options...> & x,
                          const splay_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const splay_set< T, Options...> & x,
                          const splay_set< T, Options...> & y);
        template<typename T, class... Options>
          void swap(splay_set< T, Options...> & x, splay_set< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const splay_multiset< T, Options...> & x,
                          const splay_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const splay_multiset< T, Options...> & x,
                         const splay_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const splay_multiset< T, Options...> & x,
                          const splay_multiset< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const splay_multiset< T, Options...> & x,
                          const splay_multiset< T, Options...> & y);
        template<typename T, class... Options>
          void swap(splay_multiset< T, Options...> & x,
                    splay_multiset< T, Options...> & y);
      }
    }

### Header <boost/intrusive/splaytree.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_splaytree;

        template<typename T, class... Options> class splaytree;
        template<typename T, class... Options>
          bool operator<(const splaytree< T, Options...> & x,
                         const splaytree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator==(const splaytree< T, Options...> & x,
                          const splaytree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const splaytree< T, Options...> & x,
                          const splaytree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const splaytree< T, Options...> & x,
                         const splaytree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const splaytree< T, Options...> & x,
                          const splaytree< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const splaytree< T, Options...> & x,
                          const splaytree< T, Options...> & y);
        template<typename T, class... Options>
          void swap(splaytree< T, Options...> & x, splaytree< T, Options...> & y);
      }
    }

### Header <boost/intrusive/splaytree_algorithms.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits> class splaytree_algorithms;
      }
    }

### Header <boost/intrusive/treap.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_treap;

        template<typename T, class... Options> class treap;
        template<typename T, class... Options>
          bool operator<(const treap< T, Options...> & x,
                         const treap< T, Options...> & y);
        template<typename T, class... Options>
          bool operator==(const treap< T, Options...> & x,
                          const treap< T, Options...> & y);
        template<typename T, class... Options>
          bool operator!=(const treap< T, Options...> & x,
                          const treap< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>(const treap< T, Options...> & x,
                         const treap< T, Options...> & y);
        template<typename T, class... Options>
          bool operator<=(const treap< T, Options...> & x,
                          const treap< T, Options...> & y);
        template<typename T, class... Options>
          bool operator>=(const treap< T, Options...> & x,
                          const treap< T, Options...> & y);
        template<typename T, class... Options>
          void swap(treap< T, Options...> & x, treap< T, Options...> & y);
      }
    }

### Header <boost/intrusive/treap_algorithms.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits> class treap_algorithms;
      }
    }

### Header <boost/intrusive/treap_set.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_treap_multiset;
        template<typename T, class... Options> struct make_treap_set;

        template<typename T, class... Options> class treap_multiset;
        template<typename T, class... Options> class treap_set;
      }
    }

### Header <boost/intrusive/trivial_value_traits.hpp>

    namespace boost {
      namespace intrusive {
        template<typename NodeTraits, link_mode_type LinkMode = safe_link>
          struct trivial_value_traits;
      }
    }

### Header <boost/intrusive/unordered_set.hpp>

    namespace boost {
      namespace intrusive {
        template<typename T, class... Options> struct make_unordered_multiset;
        template<typename T, class... Options> struct make_unordered_set;

        template<typename T, class... Options> class unordered_multiset;
        template<typename T, class... Options> class unordered_set;
      }
    }

### Header <boost/intrusive/unordered_set_hook.hpp>

    namespace boost {
      namespace intrusive {
        template<class... Options> struct make_unordered_set_base_hook;
        template<class... Options> struct make_unordered_set_member_hook;

        template<class... Options> class unordered_set_base_hook;
        template<class... Options> class unordered_set_member_hook;
      }
    }