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 for the latest Boost documentation.

Struct template bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrKeyEqual, BucketTraits, LinearBuckets, true>

boost::intrusive::bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrKeyEqual, BucketTraits, LinearBuckets, true>

Synopsis

// In header: <boost/intrusive/hashtable.hpp>

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> : public boost::intrusive::bucket_hash_t< ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, BucketTraits, LinearBuckets >,
                             public hashtable_equal_holder::type< ValueTraits, BucketTraits, VoidOrKeyOfValue, VoidOrKeyEqual, LinearBuckets >
{
  // types
  typedef hashtable_equal_holder< ValueTraits, BucketTraits, VoidOrKeyOfValue, VoidOrKeyEqual, LinearBuckets >::type equal_holder_t;       
  typedef bucket_plus_vtraits< ValueTraits, BucketTraits, LinearBuckets >                                            bucket_plus_vtraits_t;
  typedef ValueTraits                                                                                                value_traits;         
  typedef equal_holder_t::functor_type                                                                               key_equal;            
  typedef bucket_hash_t< ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, BucketTraits, LinearBuckets >                 bucket_hash_type;     
  typedef bucket_hash_type::hasher                                                                                   hasher;               
  typedef BucketTraits                                                                                               bucket_traits;        
  typedef bucket_plus_vtraits_t::siterator                                                                           siterator;            
  typedef bucket_plus_vtraits_t::slist_node_algorithms                                                               slist_node_algorithms;
  typedef unordered_bucket_ptr_impl< typename bucket_hash_type::value_traits >::type                                 bucket_ptr;           

  // construct/copy/destruct
  bucket_hash_equal_t(const ValueTraits &, const bucket_traits &, 
                      const hasher &, const key_equal &);
  bucket_hash_equal_t(bucket_hash_equal_t &&);

  // public member functions
  bucket_ptr priv_get_cache() const;
  void priv_set_cache(bucket_ptr);
  void priv_set_cache_bucket_num(std::size_t);
  std::size_t priv_get_cache_bucket_num();
  void priv_init_cache();
  void priv_swap_cache(bucket_hash_equal_t &);
  siterator priv_begin(bucket_ptr &) const;
  void priv_insertion_update_cache(std::size_t);
  const key_equal & priv_equal() const;
  key_equal & priv_equal();
  void priv_erasure_update_cache_range(std::size_t, std::size_t);
  void priv_erasure_update_cache(bucket_ptr);
  void priv_erasure_update_cache();

  // public data members
  bucket_ptr cached_begin_;
};

Description

`bucket_hash_equal_t` public construct/copy/destruct

bucket_hash_equal_t(const ValueTraits & val_traits, 
                    const bucket_traits & b_traits, const hasher & h, 
                    const key_equal & e);

bucket_hash_equal_t(bucket_hash_equal_t && other);

`bucket_hash_equal_t` public member functions

```
bucket_ptr priv_get_cache() const;
```
```
void priv_set_cache(bucket_ptr p);
```

void priv_set_cache_bucket_num(std::size_t insertion_bucket);

std::size_t priv_get_cache_bucket_num();

```
void priv_init_cache();
```

void priv_swap_cache(bucket_hash_equal_t & other);

siterator priv_begin(bucket_ptr & pbucketptr) const;

void priv_insertion_update_cache(std::size_t insertion_bucket);

```
const key_equal & priv_equal() const;
```
```
key_equal & priv_equal();
```

void priv_erasure_update_cache_range(std::size_t first_bucket_num, 
                                     std::size_t last_bucket_num);

void priv_erasure_update_cache(bucket_ptr first_bucket);

```
void priv_erasure_update_cache();
```