| Home | Libraries | People | FAQ | More

## Reference

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

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

        template<class... Options> class any_base_hook;

        template<class... Options> struct make_any_member_hook;

        template<class... Options> class any_member_hook;

        template<typename BaseHook> struct any_to_slist_hook;
        template<typename BaseHook> struct any_to_list_hook;
        template<typename BaseHook> struct any_to_set_hook;
        template<typename BaseHook> struct any_to_avl_set_hook;
        template<typename BaseHook> struct any_to_bs_set_hook;
        template<typename BaseHook> struct any_to_unordered_set_hook;
      }
    }

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

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

        template<typename T, class... Options> struct make_avl_set;

        template<typename T, class... Options> class avl_multiset;

        template<typename T, class... Options> struct make_avl_multiset;
        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> struct make_avl_set_base_hook;

        template<class... Options> class avl_set_base_hook;

        template<class... Options> struct make_avl_set_member_hook;

        template<class... Options> class 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_hook.hpp>

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

        template<class... Options> class bs_set_base_hook;

        template<class... Options> struct make_bs_set_member_hook;

        template<class... Options> class bs_set_member_hook;
      }
    }

### 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/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> struct make_list_base_hook;

        template<class... Options> class list_base_hook;

        template<class... Options> struct make_list_member_hook;

        template<class... Options> class 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<bool Enabled> struct constant_time_size;
        template<typename SizeType> struct size_type;
        template<typename Compare> struct compare;
        template<bool Enabled> struct floating_point;
        template<typename Equal> struct equal;
        template<typename Priority> struct priority;
        template<typename Hash> struct hash;
        template<typename ValueTraits> struct value_traits;
        template<typename Parent, typename MemberHook,
                 MemberHook Parent::* PtrToMember>
          struct member_hook;
        template<typename BaseHook> struct base_hook;
        template<typename VoidPointer> struct void_pointer;
        template<typename Tag> struct tag;
        template<link_mode_type LinkType> struct link_mode;
        template<bool Enabled> struct optimize_size;
        template<bool Enabled> struct linear;
        template<bool Enabled> struct cache_last;
        template<typename BucketTraits> struct bucket_traits;
        template<bool Enabled> struct store_hash;
        template<bool Enabled> struct optimize_multikey;
        template<bool Enabled> struct power_2_buckets;
        template<bool Enabled> struct cache_begin;
        template<bool Enabled> struct compare_hash;
        template<bool Enabled> struct incremental;
      }
    }

### 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 T, std::size_t NumBits>
          struct pointer_plus_bits<T *, NumBits>;
      }
    }

### 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> class rbtree;

        template<typename T, class... Options> struct make_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> class set;

        template<typename T, class... Options> struct make_set;

        template<typename T, class... Options> class multiset;

        template<typename T, class... Options> struct make_multiset;
        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> class set_base_hook;

        template<class... Options> struct make_set_member_hook;

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

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

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

        template<typename T, class... Options> struct make_sg_set;

        template<typename T, class... Options> class sg_multiset;

        template<typename T, class... Options> struct make_sg_multiset;
        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> class sgtree;

        template<typename T, class... Options> struct make_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> class slist;

        template<typename T, class... Options> struct make_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> class slist_base_hook;

        template<class... Options> struct make_slist_member_hook;

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

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

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

        template<typename T, class... Options> struct make_splay_set;

        template<typename T, class... Options> class splay_multiset;

        template<typename T, class... Options> struct make_splay_multiset;
        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/splay_set_hook.hpp>

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

        template<class... Options> class splay_set_base_hook;

        template<class... Options> struct make_splay_set_member_hook;

        template<class... Options> class splay_set_member_hook;
      }
    }

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

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

        template<typename T, class... Options> struct make_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> class treap;

        template<typename T, class... Options> struct make_trie;
        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> class treap_set;

        template<typename T, class... Options> struct make_treap_set;

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

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

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

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

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

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

        template<typename T, class... Options> struct make_unordered_set;

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

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

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

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

        template<class... Options> class unordered_set_base_hook;

        template<class... Options> struct make_unordered_set_member_hook;

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