forked from boostorg/unordered
50e8df5e12
Anotehr overhaul. Can now use `void_pointer` for links between nodes, although it doesn't as I don't think `void_pointer` support is strong enough in existing allocators. Also no longer relies on using base pointers for custome pointer types. And scaled back member function detection to just detect if an allocator has a member, not what its signature is. I found that the trait could be confused by ambiguous overloads. This might be fixable. Better documentation of C++11 compliance to come. [SVN r74859]
261 lines
7.5 KiB
C++
261 lines
7.5 KiB
C++
|
|
// 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
|