...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
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; } }
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); } }
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; } }
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_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); } }
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; } }
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 ValueTraits, typename VoidOrKeyOfValue, typename VoidOrKeyHash, typename VoidOrKeyEqual, typename BucketTraits, bool LinearBuckets, bool> struct bucket_hash_equal_t; template<typename ValueTraits, typename VoidOrKeyOfValue, typename VoidOrKeyHash, typename VoidOrKeyEqual, typename BucketTraits, bool LinearBuckets> struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrKeyEqual, BucketTraits, LinearBuckets, true>; template<typename ValueTraits, typename VoidOrKeyOfValue, typename VoidOrKeyHash, typename BucketTraits, bool LinearBuckets> struct bucket_hash_t; template<typename ValueTraits, typename BucketTraits, bool LinearBuckets> struct bucket_plus_vtraits; template<typename BucketPtr, typename SizeType> struct bucket_traits_impl; struct default_hashtable_hook_applier; template<typename ValueTraits, bool IsConst> struct downcast_node_to_value_t; template<typename Bucket, typename Algo, typename Disposer, typename SizeType> class exception_bucket_disposer; template<typename EqualTo, typename> struct get_equal_to; template<typename T> struct get_equal_to<void, T>; template<typename Hash, typename> struct get_hash; template<typename T> struct get_hash<void, T>; template<typename KeyOfValue, typename T> struct get_hash_key_of_value; template<typename T> struct get_hash_key_of_value<void, T>; template<typename ValueTraits, typename VoidOrKeyOfValue, typename VoidOrKeyHash, typename VoidOrKeyEqual, typename BucketTraits, typename SizeType, std::size_t BoolFlags> struct get_hashtable_size_wrapper_bucket; template<typename ValueTraits, typename VoidOrKeyOfValue, typename VoidOrKeyHash, typename VoidOrKeyEqual, typename BucketTraits, typename SizeType, std::size_t BoolFlags> struct get_hashtable_size_wrapper_internal; template<typename NodeTraits> struct group_functions; struct hash_bool_flags; template<typename T, typename VoidOrKeyOfValue, typename VoidOrKeyEqual> struct hash_key_equal; template<typename T, typename VoidOrKeyOfValue, typename VoidOrKeyHash> struct hash_key_hash; template<typename T, typename VoidOrKeyOfValue> struct hash_key_types_base; template<typename ValueTraits, typename VoidOrKeyOfValue, typename VoidOrKeyHash, typename VoidOrKeyEqual, typename BucketTraits, typename SizeType, std::size_t BoolFlags> struct hashdata_internal; template<typename T, class ... Options> class hashtable; struct hashtable_defaults; template<typename ValueTraits, typename BucketTraits, typename VoidOrKeyOfValue, typename VoidOrKeyEqual, bool LinearBuckets> struct hashtable_equal_holder; template<typename DeriveFrom, typename SizeType, bool> struct hashtable_size_wrapper; template<typename DeriveFrom, typename SizeType> struct hashtable_size_wrapper<DeriveFrom, SizeType, false>; template<typename BucketType, typename SplitTraits, typename SlistNodeAlgorithms> class incremental_rehash_rollback; struct insert_commit_data_impl; template<> struct is_default_hook_tag<default_hashtable_hook_applier>; template<typename T, class ... Options> struct make_hashtable; template<typename F, typename SlistNodePtr, typename NodePtr> struct node_cast_adaptor; template<typename NodeTraits> struct node_functions; template<typename T> struct optimize_multikey_is_true; template<typename T> struct store_hash_is_true; template<typename ValueTraitsOrHookOption> struct unordered_bucket; template<typename SupposedValueTraits> struct unordered_bucket_impl; template<typename ValueTraitsOrHookOption> struct unordered_bucket_ptr; template<typename SupposedValueTraits> struct unordered_bucket_ptr_impl; template<typename ValueTraitsOrHookOption> struct unordered_default_bucket_traits; template<typename InputIt, typename T> InputIt priv_algo_find(InputIt first, InputIt last, const T & value); template<typename InputIt, typename T> boost::intrusive::iterator_traits< InputIt >::difference_type priv_algo_count(InputIt first, InputIt last, const T & value); template<typename ForwardIterator1, typename ForwardIterator2> bool priv_algo_is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2); template<typename Node, typename SlistNodePtr> pointer_traits< SlistNodePtr >::template rebind_pointer< Node >::type dcast_bucket_ptr(const SlistNodePtr & p); std::size_t hash_to_bucket(std::size_t hash_value, std::size_t bucket_cnt, unspecified); std::size_t hash_to_bucket(std::size_t hash_value, std::size_t bucket_cnt, unspecified); // fastmod_buckets template<bool Power2Buckets, bool Incremental> std::size_t hash_to_bucket_split(std::size_t hash_value, std::size_t bucket_cnt, std::size_t split, unspecified); template<bool Power2Buckets, bool Incremental> std::size_t hash_to_bucket_split(std::size_t hash_value, std::size_t, std::size_t split, unspecified); } }
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:
Finally it forward declares the following general purpose utilities:
boost::intrusive::pointer_plus_bits / boost::intrusive::priority_compare.
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> 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; } }
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<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 fastmod_buckets; 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<typename KeyOfValue> struct key_of_value; template<bool Enabled> struct linear; template<bool Enabled> struct linear_buckets; 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 PrioOfValue> struct priority_of_value; 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; } }
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; 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>; } }
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> struct make_rbtree; template<typename T, class ... Options> class rbtree; } }
namespace boost { namespace intrusive { template<typename NodeTraits> class rbtree_algorithms; } }
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); } }
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; } }
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); } }
namespace boost { namespace intrusive { template<typename T, class ... Options> struct make_sgtree; template<typename T, class ... Options> class sgtree; } }
namespace boost { namespace intrusive { template<typename NodeTraits> class sgtree_algorithms; } }
namespace boost { namespace intrusive { template<typename T, class ... Options> struct make_slist; template<typename T, class ... Options> class slist; } }
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; } }
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); } }
namespace boost { namespace intrusive { template<typename T, class ... Options> struct make_splaytree; template<typename T, class ... Options> class splaytree; } }
namespace boost { namespace intrusive { template<typename NodeTraits> class splaytree_algorithms; } }
namespace boost { namespace intrusive { template<typename T, class ... Options> struct make_treap; template<typename T, class ... Options> class treap; } }
namespace boost { namespace intrusive { template<typename NodeTraits> class treap_algorithms; } }
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; } }
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> 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; } }
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; } }