+ assert( !n->is_dummy());
+ return base_class()(q.val, v);
+ }
+
+ int operator()( value_type const& lhs, value_type const& rhs ) const
+ {
+ splitlist_node_type const * n1 = static_cast<splitlist_node_type const *>(native_node_traits::to_node_ptr( lhs ));
+ splitlist_node_type const * n2 = static_cast<splitlist_node_type const *>(native_node_traits::to_node_ptr( rhs ));
+ if ( n1->m_nHash != n2->m_nHash )
+ return n1->m_nHash < n2->m_nHash ? -1 : 1;
+
+ if ( n1->is_dummy()) {
+ assert( n2->is_dummy());
+ return 0;
+ }
+
+ assert( !n1->is_dummy() && !n2->is_dummy());
+
+ return native_key_comparator()( lhs, rhs );
+ }
+ };
+
+ typedef typename native_ordered_list::template rebind_traits<
+ opt::compare< key_compare >
+ , opt::disposer< wrapped_disposer >
+ , opt::boundary_node_type< splitlist_node_type >
+ >::type result;
+ };
+
+ template <class OrderedList, class Traits>
+ class ordered_list_adapter< OrderedList, Traits, true >
+ {
+ typedef OrderedList native_ordered_list;
+ typedef Traits traits;
+
+ typedef typename native_ordered_list::gc gc;
+ typedef typename native_ordered_list::key_comparator native_key_comparator;
+ typedef typename native_ordered_list::value_type value_type;
+ typedef typename native_ordered_list::disposer native_disposer;
+
+ struct key_compare {
+ int operator()( value_type const& v1, value_type const& v2 ) const
+ {
+ hash_node const& n1 = static_cast<hash_node const&>( v1 );
+ hash_node const& n2 = static_cast<hash_node const&>( v2 );
+ if ( n1.m_nHash != n2.m_nHash )
+ return n1.m_nHash < n2.m_nHash ? -1 : 1;
+
+ if ( n1.is_dummy()) {
+ assert( n2.is_dummy());
+ return 0;
+ }
+
+ assert( !n1.is_dummy() && !n2.is_dummy());
+
+ return native_key_comparator()(v1, v2);
+ }
+
+ template <typename Q>
+ int operator()( value_type const& v, search_value_type<Q> const& q ) const
+ {
+ hash_node const& n = static_cast<hash_node const&>( v );
+ if ( n.m_nHash != q.nHash )
+ return n.m_nHash < q.nHash ? -1 : 1;
+
+ assert( !n.is_dummy());
+ return native_key_comparator()(v, q.val);
+ }
+
+ template <typename Q>
+ int operator()( search_value_type<Q> const& q, value_type const& v ) const
+ {
+ return -operator()( v, q );
+ }
+ };
+
+ struct wrapped_disposer
+ {
+ void operator()( value_type * v )
+ {
+ if ( !static_cast<hash_node*>( v )->is_dummy())
+ native_disposer()( v );