You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
260 lines
7.5 KiB
260 lines
7.5 KiB
|
|
// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard. |
|
// Copyright (C) 2005-2011 Daniel James |
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying |
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
|
|
|
#ifndef BOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED |
|
#define BOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED |
|
|
|
#if defined(_MSC_VER) && (_MSC_VER >= 1020) |
|
# pragma once |
|
#endif |
|
|
|
#include <boost/type_traits/is_convertible.hpp> |
|
#include <boost/type_traits/is_empty.hpp> |
|
#include <boost/iterator/iterator_categories.hpp> |
|
#include <boost/utility/enable_if.hpp> |
|
#include <boost/detail/select_type.hpp> |
|
#include <boost/move/move.hpp> |
|
#include <boost/preprocessor/seq/size.hpp> |
|
#include <boost/preprocessor/seq/enum.hpp> |
|
#include <boost/swap.hpp> |
|
|
|
namespace boost { namespace unordered { namespace detail { |
|
|
|
static const float minimum_max_load_factor = 1e-3f; |
|
static const std::size_t default_bucket_count = 11; |
|
struct move_tag {}; |
|
struct empty_emplace {}; |
|
|
|
//////////////////////////////////////////////////////////////////////////// |
|
// iterator SFINAE |
|
|
|
template <typename I> |
|
struct is_forward : |
|
boost::is_convertible< |
|
typename boost::iterator_traversal<I>::type, |
|
boost::forward_traversal_tag> |
|
{}; |
|
|
|
template <typename I, typename ReturnType> |
|
struct enable_if_forward : |
|
boost::enable_if_c< |
|
boost::unordered::detail::is_forward<I>::value, |
|
ReturnType> |
|
{}; |
|
|
|
template <typename I, typename ReturnType> |
|
struct disable_if_forward : |
|
boost::disable_if_c< |
|
boost::unordered::detail::is_forward<I>::value, |
|
ReturnType> |
|
{}; |
|
|
|
//////////////////////////////////////////////////////////////////////////// |
|
// primes |
|
|
|
#define BOOST_UNORDERED_PRIMES \ |
|
(5ul)(11ul)(17ul)(29ul)(37ul)(53ul)(67ul)(79ul) \ |
|
(97ul)(131ul)(193ul)(257ul)(389ul)(521ul)(769ul) \ |
|
(1031ul)(1543ul)(2053ul)(3079ul)(6151ul)(12289ul)(24593ul) \ |
|
(49157ul)(98317ul)(196613ul)(393241ul)(786433ul) \ |
|
(1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul) \ |
|
(50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul) \ |
|
(1610612741ul)(3221225473ul)(4294967291ul) |
|
|
|
template<class T> struct prime_list_template |
|
{ |
|
static std::size_t const value[]; |
|
|
|
#if !defined(SUNPRO_CC) |
|
static std::ptrdiff_t const length; |
|
#else |
|
static std::ptrdiff_t const length |
|
= BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES); |
|
#endif |
|
}; |
|
|
|
template<class T> |
|
std::size_t const prime_list_template<T>::value[] = { |
|
BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIMES) |
|
}; |
|
|
|
#if !defined(SUNPRO_CC) |
|
template<class T> |
|
std::ptrdiff_t const prime_list_template<T>::length |
|
= BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES); |
|
#endif |
|
|
|
#undef BOOST_UNORDERED_PRIMES |
|
|
|
typedef prime_list_template<std::size_t> prime_list; |
|
|
|
// no throw |
|
inline std::size_t next_prime(std::size_t num) { |
|
std::size_t const* const prime_list_begin = prime_list::value; |
|
std::size_t const* const prime_list_end = prime_list_begin + |
|
prime_list::length; |
|
std::size_t const* bound = |
|
std::lower_bound(prime_list_begin, prime_list_end, num); |
|
if(bound == prime_list_end) |
|
bound--; |
|
return *bound; |
|
} |
|
|
|
// no throw |
|
inline std::size_t prev_prime(std::size_t num) { |
|
std::size_t const* const prime_list_begin = prime_list::value; |
|
std::size_t const* const prime_list_end = prime_list_begin + |
|
prime_list::length; |
|
std::size_t const* bound = |
|
std::upper_bound(prime_list_begin,prime_list_end, num); |
|
if(bound != prime_list_begin) |
|
bound--; |
|
return *bound; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////////// |
|
// insert_size/initial_size |
|
|
|
#if !defined(BOOST_NO_STD_DISTANCE) |
|
|
|
using ::std::distance; |
|
|
|
#else |
|
|
|
template <class ForwardIterator> |
|
inline std::size_t distance(ForwardIterator i, ForwardIterator j) { |
|
std::size_t x; |
|
std::distance(i, j, x); |
|
return x; |
|
} |
|
|
|
#endif |
|
|
|
template <class I> |
|
inline typename |
|
boost::unordered::detail::enable_if_forward<I, std::size_t>::type |
|
insert_size(I i, I j) |
|
{ |
|
return std::distance(i, j); |
|
} |
|
|
|
template <class I> |
|
inline typename |
|
boost::unordered::detail::disable_if_forward<I, std::size_t>::type |
|
insert_size(I, I) |
|
{ |
|
return 1; |
|
} |
|
|
|
template <class I> |
|
inline std::size_t initial_size(I i, I j, |
|
std::size_t num_buckets = |
|
boost::unordered::detail::default_bucket_count) |
|
{ |
|
// TODO: Why +1? |
|
return (std::max)( |
|
boost::unordered::detail::insert_size(i, j) + 1, |
|
num_buckets); |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////////// |
|
// compressed |
|
|
|
template <typename T, int Index> |
|
struct compressed_base : private T |
|
{ |
|
compressed_base(T const& x) : T(x) {} |
|
compressed_base(T& x, move_tag) : T(boost::move(x)) {} |
|
|
|
T& get() { return *this; } |
|
T const& get() const { return *this; } |
|
}; |
|
|
|
template <typename T, int Index> |
|
struct uncompressed_base |
|
{ |
|
uncompressed_base(T const& x) : value_(x) {} |
|
uncompressed_base(T& x, move_tag) : value_(boost::move(x)) {} |
|
|
|
T& get() { return value_; } |
|
T const& get() const { return value_; } |
|
private: |
|
T value_; |
|
}; |
|
|
|
template <typename T, int Index> |
|
struct generate_base |
|
: boost::detail::if_true< |
|
boost::is_empty<T>::value |
|
>:: BOOST_NESTED_TEMPLATE then< |
|
boost::unordered::detail::compressed_base<T, Index>, |
|
boost::unordered::detail::uncompressed_base<T, Index> |
|
> |
|
{}; |
|
|
|
template <typename T1, typename T2> |
|
struct compressed |
|
: private boost::unordered::detail::generate_base<T1, 1>::type, |
|
private boost::unordered::detail::generate_base<T2, 2>::type |
|
{ |
|
typedef typename generate_base<T1, 1>::type base1; |
|
typedef typename generate_base<T2, 2>::type base2; |
|
|
|
typedef T1 first_type; |
|
typedef T2 second_type; |
|
|
|
first_type& first() { |
|
return static_cast<base1*>(this)->get(); |
|
} |
|
|
|
first_type const& first() const { |
|
return static_cast<base1 const*>(this)->get(); |
|
} |
|
|
|
second_type& second() { |
|
return static_cast<base2*>(this)->get(); |
|
} |
|
|
|
second_type const& second() const { |
|
return static_cast<base2 const*>(this)->get(); |
|
} |
|
|
|
template <typename First, typename Second> |
|
compressed(First const& x1, Second const& x2) |
|
: base1(x1), base2(x2) {} |
|
|
|
compressed(compressed const& x) |
|
: base1(x.first()), base2(x.second()) {} |
|
|
|
compressed(compressed& x, move_tag m) |
|
: base1(x.first(), m), base2(x.second(), m) {} |
|
|
|
void assign(compressed const& x) |
|
{ |
|
first() = x.first(); |
|
second() = x.second(); |
|
} |
|
|
|
void move_assign(compressed& x) |
|
{ |
|
first() = boost::move(x.first()); |
|
second() = boost::move(x.second()); |
|
} |
|
|
|
void swap(compressed& x) |
|
{ |
|
boost::swap(first(), x.first()); |
|
boost::swap(second(), x.second()); |
|
} |
|
|
|
private: |
|
// Prevent assignment just to make use of assign or |
|
// move_assign explicit. |
|
compressed& operator=(compressed const&); |
|
}; |
|
}}} |
|
|
|
#endif
|
|
|