boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-29 19:07:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/develop'

Browse Source
This commit is contained in:
Daniel James
2016-06-03 00:00:58 +01:00
parent 84dd473a5d b4a3c6f460
commit 413b45a62e
12 changed files with 148 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
.travis.yml Normal file
View File

@ -0,0 +1,38 @@
# Copyright (C) 2016 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)
# Use Trusty to get a reasonably recent version of Boost.
sudo: required
dist: trusty
language: c++
addons:
apt:
packages:
- libboost-dev
- libboost-tools-dev
matrix:
include:
- compiler: gcc
env: BJAM_TOOLSET=gcc
- compiler: gcc
env: BJAM_TOOLSET=gcc-std11
- compiler: clang
env: BJAM_TOOLSET=clang
- compiler: clang
env: BJAM_TOOLSET=clang-std11
before_script:
- |
echo "using gcc : : g++-4.8 ;" > ~/user-config.jam
echo "using gcc : std11 : g++-4.8 --std=c++11 ;" >> ~/user-config.jam
echo "using clang : : clang++ ;" >> ~/user-config.jam
echo "using clang : std11 : clang++ --std=c++11 ;" >> ~/user-config.jam
- cat ~/user-config.jam
- touch Jamroot.jam
script:
- cd test && bjam -q ${BJAM_TOOLSET} include=${TRAVIS_BUILD_DIR}/include

8
doc/changes.qbk
View File

@ -269,4 +269,12 @@ C++11 support has resulted in some breaking changes:
* Fix potential overflow when calculating number of buckets to allocate
([@https://github.com/boostorg/unordered/pull/4 GitHub #4]).
[h2 Boost 1.62.0]
* Remove use of deprecated `boost::iterator`.
* Remove `BOOST_NO_STD_DISTANCE` workaround.
* Remove `BOOST_UNORDERED_DEPRECATED_EQUALITY` warning.
* Simpler implementation of assignment, fixes an exception safety issue
for `unordered_multiset` and `unordered_multimap`. Might be a little slower.
[endsect]

10
include/boost/unordered/detail/buckets.hpp
View File

@ -21,7 +21,7 @@
#include <boost/swap.hpp>
#include <boost/assert.hpp>
#include <boost/limits.hpp>
#include <boost/iterator.hpp>
#include <iterator>
namespace boost { namespace unordered { namespace detail {
@ -56,7 +56,7 @@ namespace boost { namespace unordered { namespace iterator_detail {
template <typename Node, typename Policy>
struct l_iterator
: public boost::iterator<
: public std::iterator<
std::forward_iterator_tag,
typename Node::value_type,
std::ptrdiff_t,
@ -116,7 +116,7 @@ namespace boost { namespace unordered { namespace iterator_detail {
template <typename Node, typename Policy>
struct cl_iterator
: public boost::iterator<
: public std::iterator<
std::forward_iterator_tag,
typename Node::value_type,
std::ptrdiff_t,
@ -184,7 +184,7 @@ namespace boost { namespace unordered { namespace iterator_detail {
template <typename Node>
struct iterator
: public boost::iterator<
: public std::iterator<
std::forward_iterator_tag,
typename Node::value_type,
std::ptrdiff_t,
@ -248,7 +248,7 @@ namespace boost { namespace unordered { namespace iterator_detail {
template <typename Node>
struct c_iterator
: public boost::iterator<
: public std::iterator<
std::forward_iterator_tag,
typename Node::value_type,
std::ptrdiff_t,

30
include/boost/unordered/detail/equivalent.hpp
View File

@ -385,7 +385,14 @@ namespace boost { namespace unordered { namespace detail {
std::size_t key_hash,
iterator pos)
{
node_pointer n = a.release();
return add_node(a.release(), key_hash, pos);
}
inline iterator add_node(
node_pointer n,
std::size_t key_hash,
iterator pos)
{
n->hash_ = key_hash;
if (pos.node_) {
this->add_after_node(n, pos.node_);
@ -482,7 +489,7 @@ namespace boost { namespace unordered { namespace detail {
{
if(i == j) return;
std::size_t distance = boost::unordered::detail::distance(i, j);
std::size_t distance = std::distance(i, j);
if(distance == 1) {
node_constructor a(this->node_alloc());
a.construct_with_value2(*i);
@ -622,30 +629,17 @@ namespace boost { namespace unordered { namespace detail {
// fill_buckets
template <class NodeCreator>
static void fill_buckets(iterator n, table& dst,
NodeCreator& creator)
void fill_buckets(iterator n, NodeCreator& creator)
{
link_pointer prev = dst.get_previous_start();
while (n.node_) {
std::size_t key_hash = n.node_->hash_;
iterator group_end(n.node_->group_prev_->next_);
node_pointer first_node = creator.create(*n);
node_pointer end = first_node;
first_node->hash_ = key_hash;
prev->next_ = first_node;
++dst.size_;
iterator pos = this->add_node(creator.create(*n), key_hash, iterator());
for (++n; n != group_end; ++n)
{
end = creator.create(*n);
end->hash_ = key_hash;
add_after_node(end, first_node);
++dst.size_;
this->add_node(creator.create(*n), key_hash, pos);
}
prev = place_in_bucket(dst, prev, end);
}
}

22
include/boost/unordered/detail/table.hpp
View File

@ -23,18 +23,6 @@
#pragma warning(disable:4127) // conditional expression is constant
#endif
#if defined(BOOST_UNORDERED_DEPRECATED_EQUALITY)
#if defined(__EDG__)
#elif defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
#pragma message("Warning: BOOST_UNORDERED_DEPRECATED_EQUALITY is no longer supported.")
#elif defined(__GNUC__) || defined(__HP_aCC) || \
defined(__SUNPRO_CC) || defined(__IBMCPP__)
#warning "BOOST_UNORDERED_DEPRECATED_EQUALITY is no longer supported."
#endif
#endif
namespace boost { namespace unordered { namespace detail {
////////////////////////////////////////////////////////////////////////////
@ -405,7 +393,7 @@ namespace boost { namespace unordered { namespace detail {
if (x.size_) {
create_buckets(bucket_count_);
copy_nodes<node_allocator> node_creator(node_alloc());
table_impl::fill_buckets(x.begin(), *this, node_creator);
static_cast<table_impl*>(this)->fill_buckets(x.begin(), node_creator);
}
}
@ -420,7 +408,7 @@ namespace boost { namespace unordered { namespace detail {
move_nodes<node_allocator> node_creator(node_alloc());
node_holder<node_allocator> nodes(x);
table_impl::fill_buckets(nodes.begin(), *this, node_creator);
static_cast<table_impl*>(this)->fill_buckets(nodes.begin(), node_creator);
}
}
@ -666,7 +654,7 @@ namespace boost { namespace unordered { namespace detail {
// assigning to them if possible, and deleting any that are
// left over.
assign_nodes<table> node_creator(*this);
table_impl::fill_buckets(x.begin(), *this, node_creator);
static_cast<table_impl*>(this)->fill_buckets(x.begin(), node_creator);
}
void assign(table const& x, true_type)
@ -693,7 +681,7 @@ namespace boost { namespace unordered { namespace detail {
if (x.size_) {
create_buckets(bucket_count_);
copy_nodes<node_allocator> node_creator(node_alloc());
table_impl::fill_buckets(x.begin(), *this, node_creator);
static_cast<table_impl*>(this)->fill_buckets(x.begin(), node_creator);
}
}
}
@ -752,7 +740,7 @@ namespace boost { namespace unordered { namespace detail {
// any that are left over.
move_assign_nodes<table> node_creator(*this);
node_holder<node_allocator> nodes(x);
table_impl::fill_buckets(nodes.begin(), *this, node_creator);
static_cast<table_impl*>(this)->fill_buckets(nodes.begin(), node_creator);
}
}

23
include/boost/unordered/detail/unique.hpp
View File

@ -311,7 +311,13 @@ namespace boost { namespace unordered { namespace detail {
node_constructor& a,
std::size_t key_hash)
{
node_pointer n = a.release();
return add_node(a.release(), key_hash);
}
inline iterator add_node(
node_pointer n,
std::size_t key_hash)
{
n->hash_ = key_hash;
bucket_pointer b = this->get_bucket(this->hash_to_bucket(key_hash));
@ -577,19 +583,10 @@ namespace boost { namespace unordered { namespace detail {
// fill_buckets
template <class NodeCreator>
static void fill_buckets(iterator n, table& dst,
NodeCreator& creator)
void fill_buckets(iterator n, NodeCreator& creator)
{
link_pointer prev = dst.get_previous_start();
while (n.node_) {
node_pointer node = creator.create(*n);
node->hash_ = n.node_->hash_;
prev->next_ = node;
++dst.size_;
++n;
prev = place_in_bucket(dst, prev);
for (; n.node_; ++n) {
this->add_node(creator.create(*n), n.node_->hash_);
}
}

15
include/boost/unordered/detail/util.hpp
View File

@ -124,21 +124,6 @@ namespace boost { namespace unordered { namespace detail {
////////////////////////////////////////////////////////////////////////////
// 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

78
test/exception/assign_exception_tests.cpp
View File

@ -38,21 +38,18 @@ struct self_assign_test2 : self_assign_base<T>
template <class T>
struct assign_base : public test::exception_base
{
const test::random_values<T> x_values, y_values;
test::random_values<T> x_values, y_values;
T x,y;
typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
assign_base(unsigned int count1, unsigned int count2, int tag1, int tag2,
float mlf1 = 1.0, float mlf2 = 1.0) :
x_values(count1),
y_values(count2),
x(x_values.begin(), x_values.end(), 0, hasher(tag1), key_equal(tag1),
allocator_type(tag1)),
y(y_values.begin(), y_values.end(), 0, hasher(tag2), key_equal(tag2),
allocator_type(tag2))
assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
x_values(),
y_values(),
x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
{
x.max_load_factor(mlf1);
y.max_load_factor(mlf2);
@ -66,47 +63,80 @@ struct assign_base : public test::exception_base
test::check_equivalent_keys(x1);
// If the container is empty at the point of the exception, the
// internal structure is hidden, this exposes it.
T& y = const_cast<T&>(x1);
// internal structure is hidden, this exposes it, at the cost of
// messing up the data.
if (x_values.size()) {
y.emplace(*x_values.begin());
test::check_equivalent_keys(y);
T& x2 = const_cast<T&>(x1);
x2.emplace(*x_values.begin());
test::check_equivalent_keys(x2);
}
}
};
template <class T>
struct assign_test1 : assign_base<T>
struct assign_values : assign_base<T>
{
assign_test1() : assign_base<T>(0, 0, 0, 0) {}
assign_values(unsigned int count1, unsigned int count2,
int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
assign_base<T>(tag1, tag2, mlf1, mlf2)
{
this->x_values.fill(count1);
this->y_values.fill(count2);
this->x.insert(this->x_values.begin(), this->x_values.end());
this->y.insert(this->y_values.begin(), this->y_values.end());
}
};
template <class T>
struct assign_test2 : assign_base<T>
struct assign_test1 : assign_values<T>
{
assign_test2() : assign_base<T>(60, 0, 0, 0) {}
assign_test1() : assign_values<T>(0, 0, 0, 0) {}
};
template <class T>
struct assign_test3 : assign_base<T>
struct assign_test2 : assign_values<T>
{
assign_test3() : assign_base<T>(0, 60, 0, 0) {}
assign_test2() : assign_values<T>(60, 0, 0, 0) {}
};
template <class T>
struct assign_test4 : assign_base<T>
struct assign_test3 : assign_values<T>
{
assign_test4() : assign_base<T>(10, 10, 1, 2) {}
assign_test3() : assign_values<T>(0, 60, 0, 0) {}
};
template <class T>
struct assign_test5 : assign_base<T>
struct assign_test4 : assign_values<T>
{
assign_test5() : assign_base<T>(5, 60, 0, 0, 1.0, 0.1) {}
assign_test4() : assign_values<T>(10, 10, 1, 2) {}
};
template <class T>
struct assign_test5 : assign_values<T>
{
assign_test5() : assign_values<T>(5, 60, 0, 0, 1.0f, 0.1f) {}
};
template <class T>
struct equivalent_test1 : assign_base<T>
{
equivalent_test1() :
assign_base<T>(0, 0)
{
test::random_values<T> x_values2(10);
this->x_values.insert(x_values2.begin(), x_values2.end());
this->x_values.insert(x_values2.begin(), x_values2.end());
test::random_values<T> y_values2(10);
this->y_values.insert(y_values2.begin(), y_values2.end());
this->y_values.insert(y_values2.begin(), y_values2.end());
this->x.insert(this->x_values.begin(), this->x_values.end());
this->y.insert(this->y_values.begin(), this->y_values.end());
}
};
EXCEPTION_TESTS(
(self_assign_test1)(self_assign_test2)
(assign_test1)(assign_test2)(assign_test3)(assign_test4)(assign_test5),
(assign_test1)(assign_test2)(assign_test3)(assign_test4)(assign_test5)
(equivalent_test1),
CONTAINER_SEQ)
RUN_TESTS()

6
test/helpers/input_iterator.hpp
View File

@ -7,8 +7,8 @@
#define BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER
#include <boost/config.hpp>
#include <boost/iterator.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <iterator>
namespace test
{
@ -28,7 +28,7 @@ namespace test
template <class Iterator>
struct input_iterator_adaptor
: public boost::iterator<
: public std::iterator<
std::input_iterator_tag,
BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
std::ptrdiff_t,
@ -72,7 +72,7 @@ namespace test
template <class Iterator>
struct copy_iterator_adaptor
: public boost::iterator<
: public std::iterator<
BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,

6
test/helpers/list.hpp
View File

@ -11,8 +11,8 @@
#if !defined(UNORDERED_TEST_LIST_HEADER)
#define UNORDERED_TEST_LIST_HEADER
#include <boost/iterator.hpp>
#include <boost/limits.hpp>
#include <iterator>
#include <functional>
namespace test
@ -83,7 +83,7 @@ namespace test
template <typename T>
class list_iterator
: public boost::iterator<
: public std::iterator<
std::forward_iterator_tag, T,
int, T*, T&>
{
@ -109,7 +109,7 @@ namespace test
template <typename T>
class list_const_iterator
: public boost::iterator<
: public std::iterator<
std::forward_iterator_tag, T,
int, T const*, T const&>
{

10
test/helpers/random_values.hpp
View File

@ -103,8 +103,16 @@ namespace test
struct random_values
: public test::list<BOOST_DEDUCED_TYPENAME X::value_type>
{
random_values(int count, test::random_generator const& generator =
random_values() {}
explicit random_values(int count, test::random_generator const& generator =
test::default_generator)
{
fill(count, generator);
}
void fill(int count, test::random_generator const& generator =
test::default_generator)
{
test::unordered_generator<X> gen(generator);
gen.fill(*this, count);

3
test/unordered/insert_tests.cpp
View File

@ -9,7 +9,6 @@
#include "../helpers/postfix.hpp"
#include "../helpers/test.hpp"
#include <boost/predef.h>
#include <boost/next_prior.hpp>
#include "../objects/test.hpp"
#include "../helpers/random_values.hpp"
@ -599,7 +598,7 @@ UNORDERED_AUTO_TEST(insert_initializer_list_set)
boost::unordered_set<initialize_from_two_ints> set2;
#if BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4,5,0)
#if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5))
set2.insert({{1, 2}});
#else
set2.insert({1, 2});