Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Reference

Header <boost/intrusive/any_hook.hpp>
Header <boost/intrusive/avl_set.hpp>
Header <boost/intrusive/avl_set_hook.hpp>
Header <boost/intrusive/avltree.hpp>
Header <boost/intrusive/avltree_algorithms.hpp>
Header <boost/intrusive/bs_set.hpp>
Header <boost/intrusive/bs_set_hook.hpp>
Header <boost/intrusive/bstree.hpp>
Header <boost/intrusive/bstree_algorithms.hpp>
Header <boost/intrusive/circular_list_algorithms.hpp>
Header <boost/intrusive/circular_slist_algorithms.hpp>
Header <boost/intrusive/derivation_value_traits.hpp>
Header <boost/intrusive/hashtable.hpp>
Header <boost/intrusive/intrusive_fwd.hpp>
Header <boost/intrusive/linear_slist_algorithms.hpp>
Header <boost/intrusive/link_mode.hpp>
Header <boost/intrusive/list.hpp>
Header <boost/intrusive/list_hook.hpp>
Header <boost/intrusive/member_value_traits.hpp>
Header <boost/intrusive/options.hpp>
Header <boost/intrusive/pack_options.hpp>
Header <boost/intrusive/parent_from_member.hpp>
Header <boost/intrusive/pointer_plus_bits.hpp>
Header <boost/intrusive/pointer_rebind.hpp>
Header <boost/intrusive/pointer_traits.hpp>
Header <boost/intrusive/priority_compare.hpp>
Header <boost/intrusive/rbtree.hpp>
Header <boost/intrusive/rbtree_algorithms.hpp>
Header <boost/intrusive/set.hpp>
Header <boost/intrusive/set_hook.hpp>
Header <boost/intrusive/sg_set.hpp>
Header <boost/intrusive/sgtree.hpp>
Header <boost/intrusive/sgtree_algorithms.hpp>
Header <boost/intrusive/slist.hpp>
Header <boost/intrusive/slist_hook.hpp>
Header <boost/intrusive/splay_set.hpp>
Header <boost/intrusive/splaytree.hpp>
Header <boost/intrusive/splaytree_algorithms.hpp>
Header <boost/intrusive/treap.hpp>
Header <boost/intrusive/treap_algorithms.hpp>
Header <boost/intrusive/treap_set.hpp>
Header <boost/intrusive/trivial_value_traits.hpp>
Header <boost/intrusive/unordered_set.hpp>
Header <boost/intrusive/unordered_set_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 BasicHook> struct any_to_slist_hook;
    template<typename BasicHook> struct any_to_list_hook;
    template<typename BasicHook> struct any_to_set_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_unordered_set_hook;
  }
}
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);
  }
}
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;
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, class... Options> class avltree;

    template<typename T, class... Options> struct make_avltree;
  }
}
namespace boost {
  namespace intrusive {
    template<typename NodeTraits> class avltree_algorithms;
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, class... Options> class bs_set;

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

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

    template<typename T, class... Options> struct make_bs_multiset;
    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);
  }
}
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;
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, class... Options> class bstree;

    template<typename T, class... Options> struct make_bstree;
  }
}
namespace boost {
  namespace intrusive {
    template<typename NodeTraits> class bstree_algorithms;
  }
}
namespace boost {
  namespace intrusive {
    template<typename NodeTraits> class circular_list_algorithms;
  }
}
namespace boost {
  namespace intrusive {
    template<typename NodeTraits> class circular_slist_algorithms;
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, typename NodeTraits, 
             link_mode_type LinkMode = safe_link> 
      struct derivation_value_traits;
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, class... Options> class hashtable;

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

This header file forward declares most Intrusive classes.

It forward declares the following containers and hooks:

It forward declares the following container or hook options:

It forward declares the following value traits utilities:

Finally it forward declares the following general purpose utilities:

namespace boost {
  namespace intrusive {
    template<typename NodeTraits> class linear_slist_algorithms;
  }
}
namespace boost {
  namespace intrusive {
    enum link_mode_type;
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, class... Options> class list;

    template<typename T, class... Options> struct make_list;
  }
}
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;
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, typename NodeTraits, 
             typename NodeTraits::node T::* PtrToMember, 
             link_mode_type LinkMode = safe_link> 
      struct member_value_traits;
  }
}
namespace boost {
  namespace intrusive {
    template<bool Enabled> struct constant_time_size;
    template<typename HeaderHolder> struct header_holder_type;
    template<typename SizeType> struct size_type;
    template<typename Compare> struct compare;
    template<typename KeyOfValue> struct key_of_value;
    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 Functor> struct function_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;
  }
}

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;
  }
}
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::*);
  }
}
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>;
  }
}
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_mode;
    template<typename Ptr, typename U, unsigned int RebindMode> 
      struct pointer_rebinder;

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

    template<typename Ptr, typename U> struct pointer_rebind;

    template<typename T, typename U> struct pointer_rebind<T *, U>;
  }
}
namespace boost {
  namespace intrusive {
    template<typename Ptr> struct pointer_traits;

    template<typename T> struct pointer_traits<T *>;
  }
}
namespace boost {
  namespace intrusive {
    template<typename T = void> struct priority_compare;

    template<> struct priority_compare<void>;
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, class... Options> class rbtree;

    template<typename T, class... Options> struct make_rbtree;
  }
}
namespace boost {
  namespace intrusive {
    template<typename NodeTraits> class rbtree_algorithms;
  }
}
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);
  }
}
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;
  }
}
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);
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, class... Options> class sgtree;

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

    template<typename T, class... Options> struct make_slist;
  }
}
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;
  }
}
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);
  }
}
namespace boost {
  namespace intrusive {
    template<typename T, class... Options> class splaytree;

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

    template<typename T, class... Options> struct make_treap;
  }
}
namespace boost {
  namespace intrusive {
    template<typename NodeTraits> class treap_algorithms;
  }
}
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;
  }
}
namespace boost {
  namespace intrusive {
    template<typename NodeTraits, link_mode_type LinkMode = safe_link> 
      struct trivial_value_traits;
  }
}
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;
  }
}
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;
  }
}

PrevUpHomeNext