template< Options> class any_base_hook;
    template< 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< Options> struct make_any_base_hook;
    template< Options> struct make_any_member_hook;
  }
}

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

    template<typename T,  Options> struct make_avl_multiset;
    template<typename T,  Options> struct make_avl_set;
    template<typename T,  Options> 
       (avl_set<  x, 
                      avl_set<  y);
    template<typename T,  Options> 
       (avl_set<  x, 
                     avl_set<  y);
    template<typename T,  Options> 
       (avl_set<  x, 
                      avl_set<  y);
    template<typename T,  Options> 
       (avl_set<  x, 
                      avl_set<  y);
    template<typename T,  Options> 
       (avl_set<  x, avl_set<  y);
    template<typename T,  Options> 
       (avl_multiset<  x, 
                      avl_multiset<  y);
    template<typename T,  Options> 
       (avl_multiset<  x, 
                     avl_multiset<  y);
    template<typename T,  Options> 
       (avl_multiset<  x, 
                      avl_multiset<  y);
    template<typename T,  Options> 
       (avl_multiset<  x, 
                      avl_multiset<  y);
    template<typename T,  Options> 
       (avl_multiset<  x, 
                avl_multiset<  y);
  }
}

  
    template< Options> class avl_set_base_hook;
    template< Options> class avl_set_member_hook;

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

  
    template<typename T,  Options> class avltree;

    template<typename T,  Options> struct make_avltree;
  }
}

  
    template<typename NodeTraits> class avltree_algorithms;
  }
}

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

    template<typename T,  Options> struct make_bs_multiset;
    template<typename T,  Options> struct make_bs_set;
    template<typename T,  Options> 
       (bs_set<  x, 
                      bs_set<  y);
    template<typename T,  Options> 
       (bs_set<  x, 
                     bs_set<  y);
    template<typename T,  Options> 
       (bs_set<  x, 
                      bs_set<  y);
    template<typename T,  Options> 
       (bs_set<  x, 
                      bs_set<  y);
    template<typename T,  Options> 
       (bs_set<  x, bs_set<  y);
    template<typename T,  Options> 
       (bs_multiset<  x, 
                      bs_multiset<  y);
    template<typename T,  Options> 
       (bs_multiset<  x, 
                     bs_multiset<  y);
    template<typename T,  Options> 
       (bs_multiset<  x, 
                      bs_multiset<  y);
    template<typename T,  Options> 
       (bs_multiset<  x, 
                      bs_multiset<  y);
    template<typename T,  Options> 
       (bs_multiset<  x, 
                bs_multiset<  y);
  }
}

  
    template< Options> class bs_set_base_hook;
    template< Options> class bs_set_member_hook;

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

  
    template<typename T,  Options> class bstree;

    template<typename T,  Options> struct make_bstree;
  }
}

  
    template<typename NodeTraits> class bstree_algorithms;
  }
}

  
    template<typename NodeTraits> class circular_list_algorithms;
  }
}

  
    template<typename NodeTraits> class circular_slist_algorithms;
  }
}

  
    template<typename T, typename NodeTraits, 
              LinkMode = > 
      struct derivation_value_traits;
  }
}

  
    template<typename ValueTraits, typename VoidOrKeyOfValue, 
             typename VoidOrKeyHash, typename VoidOrKeyEqual, 
             typename BucketTraits,  LinearBuckets,  > 
      struct bucket_hash_equal_t;

    template<typename ValueTraits, typename VoidOrKeyOfValue, 
             typename VoidOrKeyHash, typename VoidOrKeyEqual, 
             typename BucketTraits,  LinearBuckets> 
      struct bucket_hash_equal_t<, , , , , , >;

    template<typename ValueTraits, typename VoidOrKeyOfValue, 
             typename VoidOrKeyHash, typename BucketTraits, 
              LinearBuckets> 
      struct bucket_hash_t;
    template<typename ValueTraits, typename BucketTraits,  LinearBuckets> 
      struct bucket_plus_vtraits;
    template<typename BucketPtr, typename SizeType> struct bucket_traits_impl;
    struct default_hashtable_hook_applier;
    template<typename ValueTraits,  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<, >;

    template<typename Hash, typename > struct get_hash;

    template<typename T> struct get_hash<, >;

    template<typename KeyOfValue, typename T> struct get_hash_key_of_value;

    template<typename T> struct get_hash_key_of_value<, >;

    template<typename ValueTraits, typename VoidOrKeyOfValue, 
             typename VoidOrKeyHash, typename VoidOrKeyEqual, 
             typename BucketTraits, typename SizeType,  BoolFlags> 
      struct get_hashtable_size_wrapper_bucket;
    template<typename ValueTraits, typename VoidOrKeyOfValue, 
             typename VoidOrKeyHash, typename VoidOrKeyEqual, 
             typename BucketTraits, typename SizeType,  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,  BoolFlags> 
      struct hashdata_internal;

    template<typename T,  Options> class hashtable;

    struct hashtable_defaults;
    template<typename ValueTraits, typename BucketTraits, 
             typename VoidOrKeyOfValue, typename VoidOrKeyEqual, 
              LinearBuckets> 
      struct hashtable_equal_holder;
    template<typename DeriveFrom, typename SizeType,  > 
      struct hashtable_size_wrapper;

    template<typename DeriveFrom, typename SizeType> 
      struct hashtable_size_wrapper<, , >;

    template<typename BucketType, typename SplitTraits, 
             typename SlistNodeAlgorithms> 
      class incremental_rehash_rollback;

    template< StoreHash> struct insert_commit_data_impl;

    template<> struct insert_commit_data_impl<>;
    template<> struct is_default_hook_tag<>;

    template<typename T,  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> 
       ( first,  last,  value);
    template<typename InputIt, typename T> 
       
      ( first,  last,  value);
    template<typename ForwardIterator1, typename ForwardIterator2> 
       ( first1, 
                                     last1, 
                                     first2);
    template<typename Node, typename SlistNodePtr> 
      pointer_traits<  
      ( p);
     ( hash_value,  bucket_cnt, 
                               );
     ( hash_value,  bucket_cnt, 
                               );

    // fastmod_buckets
    template< Power2Buckets,  Incremental> 
       ( hash_value, 
                                        bucket_cnt, 
                                        split, );
    template< Power2Buckets,  Incremental> 
       ( hash_value, , 
                                        split, );
  }
}

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:

  
    template<typename NodeTraits> class linear_slist_algorithms;
  }
}

  
    enum link_mode_type;
  }
}

  
    template<typename T,  Options> class list;

    template<typename T,  Options> struct make_list;
  }
}

  
    template< Options> class list_base_hook;
    template< Options> class list_member_hook;

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

  
    template<typename T, typename NodeTraits, 
              PtrToMember, 
              LinkMode = > 
      struct member_value_traits;
  }
}

  
    template<typename BaseHook> struct base_hook;
    template<typename BucketTraits> struct bucket_traits;
    template< Enabled> struct cache_begin;
    template< Enabled> struct cache_last;
    template<typename Compare> struct compare;
    template< Enabled> struct compare_hash;
    template< Enabled> struct constant_time_size;
    template<typename Equal> struct equal;
    template< Enabled> struct fastmod_buckets;
    template< Enabled> struct floating_point;
    template<typename Functor> struct function_hook;
    template<typename Hash> struct hash;
    template<typename HeaderHolder> struct header_holder_type;
    template< Enabled> struct incremental;
    template<typename KeyOfValue> struct key_of_value;
    template< Enabled> struct linear;
    template< Enabled> struct linear_buckets;
    template< LinkType> struct link_mode;
    template<typename Parent, typename MemberHook, 
              PtrToMember> 
      struct member_hook;
    template< Enabled> struct optimize_multikey;
    template< Enabled> struct optimize_size;
    template< Enabled> struct power_2_buckets;
    template<typename Priority> struct priority;
    template<typename PrioOfValue> struct priority_of_value;
    template<typename SizeType> struct size_type;
    template< 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)

  
    template<typename DefaultOptions,  Options> struct pack_options;
  }
}

  
    template<typename Parent, typename Member> 
       (, );
    template<typename Parent, typename Member> 
       
      (, );
  }
}

  
    template<typename VoidPointer,  Alignment> struct max_pointer_plus_bits;

    template< Alignment> struct max_pointer_plus_bits<, >;

    template<typename Pointer,  NumBits> struct pointer_plus_bits;

    template<typename T,  NumBits> struct pointer_plus_bits<, >;
  }
}

  
    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<, >;

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

    template<typename Ptr, typename U> struct pointer_rebinder<, , >;
    template<typename Ptr, typename U> struct pointer_rebinder<, , >;
    template< Ptr, typename A, typename U> struct pointer_rebinder<, , >;
    template< Ptr, typename A,  An, 
             typename U> struct pointer_rebinder<, , , >;
  }
}

  
    template<typename Ptr> struct pointer_traits;

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

  
    template<typename T> struct priority_compare;

    template<> struct priority_compare<>;
  }
}

  
    template<typename T,  Options> struct make_rbtree;

    template<typename T,  Options> class rbtree;
  }
}

  
    template<typename NodeTraits> class rbtree_algorithms;
  }
}

  
    template<typename T,  Options> struct make_multiset;
    template<typename T,  Options> struct make_set;

    template<typename T,  Options> class multiset;
    template<typename T,  Options> class set;
    template<typename T,  Options> 
       (set<  x, 
                      set<  y);
    template<typename T,  Options> 
       (set<  x, 
                     set<  y);
    template<typename T,  Options> 
       (set<  x, 
                      set<  y);
    template<typename T,  Options> 
       (set<  x, 
                      set<  y);
    template<typename T,  Options> 
       (set<  x, set<  y);
    template<typename T,  Options> 
       (multiset<  x, 
                      multiset<  y);
    template<typename T,  Options> 
       (multiset<  x, 
                     multiset<  y);
    template<typename T,  Options> 
       (multiset<  x, 
                      multiset<  y);
    template<typename T,  Options> 
       (multiset<  x, 
                      multiset<  y);
    template<typename T,  Options> 
       (multiset<  x, multiset<  y);
  }
}

  
    template< Options> struct make_set_base_hook;
    template< Options> struct make_set_member_hook;

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

  
    template<typename T,  Options> struct make_sg_multiset;
    template<typename T,  Options> struct make_sg_set;

    template<typename T,  Options> class sg_multiset;
    template<typename T,  Options> class sg_set;
    template<typename T,  Options> 
       (sg_set<  x, 
                      sg_set<  y);
    template<typename T,  Options> 
       (sg_set<  x, 
                     sg_set<  y);
    template<typename T,  Options> 
       (sg_set<  x, 
                      sg_set<  y);
    template<typename T,  Options> 
       (sg_set<  x, 
                      sg_set<  y);
    template<typename T,  Options> 
       (sg_set<  x, sg_set<  y);
    template<typename T,  Options> 
       (sg_multiset<  x, 
                      sg_multiset<  y);
    template<typename T,  Options> 
       (sg_multiset<  x, 
                     sg_multiset<  y);
    template<typename T,  Options> 
       (sg_multiset<  x, 
                      sg_multiset<  y);
    template<typename T,  Options> 
       (sg_multiset<  x, 
                      sg_multiset<  y);
    template<typename T,  Options> 
       (sg_multiset<  x, 
                sg_multiset<  y);
  }
}

  
    template<typename T,  Options> struct make_sgtree;

    template<typename T,  Options> class sgtree;
  }
}

  
    template<typename NodeTraits> class sgtree_algorithms;
  }
}

  
    template<typename T,  Options> struct make_slist;

    template<typename T,  Options> class slist;
  }
}

  
    template< Options> struct make_slist_base_hook;
    template< Options> struct make_slist_member_hook;

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

  
    template<typename T,  Options> struct make_splay_multiset;
    template<typename T,  Options> struct make_splay_set;

    template<typename T,  Options> class splay_multiset;
    template<typename T,  Options> class splay_set;
    template<typename T,  Options> 
       (splay_set<  x, 
                      splay_set<  y);
    template<typename T,  Options> 
       (splay_set<  x, 
                     splay_set<  y);
    template<typename T,  Options> 
       (splay_set<  x, 
                      splay_set<  y);
    template<typename T,  Options> 
       (splay_set<  x, 
                      splay_set<  y);
    template<typename T,  Options> 
       (splay_set<  x, 
                splay_set<  y);
    template<typename T,  Options> 
       (splay_multiset<  x, 
                      splay_multiset<  y);
    template<typename T,  Options> 
       (splay_multiset<  x, 
                     splay_multiset<  y);
    template<typename T,  Options> 
       (splay_multiset<  x, 
                      splay_multiset<  y);
    template<typename T,  Options> 
       (splay_multiset<  x, 
                      splay_multiset<  y);
    template<typename T,  Options> 
       (splay_multiset<  x, 
                splay_multiset<  y);
  }
}

  
    template<typename T,  Options> struct make_splaytree;

    template<typename T,  Options> class splaytree;
  }
}

  
    template<typename NodeTraits> class splaytree_algorithms;
  }
}

  
    template<typename T,  Options> struct make_treap;

    template<typename T,  Options> class treap;
  }
}

  
    template<typename NodeTraits> class treap_algorithms;
  }
}

  
    template<typename T,  Options> struct make_treap_multiset;
    template<typename T,  Options> struct make_treap_set;

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

  
    template<typename NodeTraits,  LinkMode = > struct trivial_value_traits;
  }
}

  
    template<typename T,  Options> struct make_unordered_multiset;
    template<typename T,  Options> struct make_unordered_set;

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

  
    template< Options> struct make_unordered_set_base_hook;
    template< Options> struct make_unordered_set_member_hook;

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