boost_mirror/intrusive
1
0
Fork 0
mirror of https://github.com/boostorg/intrusive.git synced 2025-05-11 13:13:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Support GCC's -Wconversion -Wfloat-conversion -Warith-conversion -Wsign-conversion warnings.

Browse Source
This commit is contained in:
Ion Gaztañaga 2021-10-16 15:56:54 +02:00
parent a4180b9e9f
commit 2eeee6cb4c
23 changed files with 337 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
example/doc_clone_from.cpp
View File

@ -47,13 +47,13 @@ struct delete_disposer
int main() int main()
{ {
const int MaxElem = 100; const std::size_t MaxElem = 100;
std::vector<my_class> nodes(MaxElem); std::vector<my_class> nodes(MaxElem);
//Fill all the nodes and insert them in the list //Fill all the nodes and insert them in the list
my_class_list list; my_class_list list;
for(int i = 0; i < MaxElem; ++i) nodes[i].int_ = i; for(std::size_t i = 0; i < MaxElem; ++i) nodes[i].int_ = (int)i;
list.insert(list.end(), nodes.begin(), nodes.end()); list.insert(list.end(), nodes.begin(), nodes.end());

8
example/doc_iterator_from_value.cpp
View File

@ -57,7 +57,7 @@ typedef boost::intrusive::unordered_set
int main() int main()
{ {
//Create MaxElem objects //Create MaxElem objects
const int MaxElem = 100; const std::size_t MaxElem = 100;
std::vector<intrusive_data> nodes(MaxElem); std::vector<intrusive_data> nodes(MaxElem);
//Declare the intrusive containers //Declare the intrusive containers
@ -67,7 +67,7 @@ int main()
(unordered_set_t::bucket_traits(buckets, MaxElem)); (unordered_set_t::bucket_traits(buckets, MaxElem));
//Initialize all the nodes //Initialize all the nodes
for(int i = 0; i < MaxElem; ++i) nodes[i].set(i); for(std::size_t i = 0; i < MaxElem; ++i) nodes[i].set((int)i);
//Now insert them in both intrusive containers //Now insert them in both intrusive containers
list.insert(list.end(), nodes.begin(), nodes.end()); list.insert(list.end(), nodes.begin(), nodes.end());
@ -75,7 +75,7 @@ int main()
//Now check the iterator_to function //Now check the iterator_to function
list_t::iterator list_it(list.begin()); list_t::iterator list_it(list.begin());
for(int i = 0; i < MaxElem; ++i, ++list_it) for(std::size_t i = 0; i < MaxElem; ++i, ++list_it)
if(list.iterator_to(nodes[i]) != list_it || if(list.iterator_to(nodes[i]) != list_it ||
list_t::s_iterator_to(nodes[i]) != list_it) list_t::s_iterator_to(nodes[i]) != list_it)
return 1; return 1;
@ -83,7 +83,7 @@ int main()
//Now check unordered_set::s_iterator_to (which is a member function) //Now check unordered_set::s_iterator_to (which is a member function)
//and unordered_set::s_local_iterator_to (which is an static member function) //and unordered_set::s_local_iterator_to (which is an static member function)
unordered_set_t::iterator unordered_set_it(unordered_set.begin()); unordered_set_t::iterator unordered_set_it(unordered_set.begin());
for(int i = 0; i < MaxElem; ++i){ for(std::size_t i = 0; i < MaxElem; ++i){
unordered_set_it = unordered_set.find(nodes[i]); unordered_set_it = unordered_set.find(nodes[i]);
if(unordered_set.iterator_to(nodes[i]) != unordered_set_it) if(unordered_set.iterator_to(nodes[i]) != unordered_set_it)
return 1; return 1;

6
example/doc_offset_ptr.cpp
View File

@ -68,8 +68,8 @@ int main()
{ {
//Now create an intrusive list in shared memory: //Now create an intrusive list in shared memory:
//nodes and the container itself must be created in shared memory //nodes and the container itself must be created in shared memory
const int MaxElem = 100; const std::size_t MaxElem = 100;
const int ShmSize = 50000; const std::size_t ShmSize = 50000;
const char *ShmName = get_shared_memory_name(); const char *ShmName = get_shared_memory_name();
{ {
//Erase all old shared memory //Erase all old shared memory
@ -88,7 +88,7 @@ int main()
pshm_vect->resize(MaxElem); pshm_vect->resize(MaxElem);
//Initialize all the nodes //Initialize all the nodes
for(int i = 0; i < MaxElem; ++i) (*pshm_vect)[i].set(i); for(std::size_t i = 0; i < MaxElem; ++i) (*pshm_vect)[i].set((int)i);
//Now create the shared memory intrusive list //Now create the shared memory intrusive list
intrusive_list_t *plist = shm.construct<intrusive_list_t>(ip::anonymous_instance)(); intrusive_list_t *plist = shm.construct<intrusive_list_t>(ip::anonymous_instance)();

10
example/doc_positional_insertion.cpp
View File

@ -40,21 +40,21 @@ int main()
//as multiset's comparison predicate, so we can just push back //as multiset's comparison predicate, so we can just push back
//all elements, which is more efficient than normal insertion //all elements, which is more efficient than normal insertion
multiset<MyClass> mset; multiset<MyClass> mset;
for(int i = 0; i < 100; ++i) mset.push_back(values[i]); for(std::size_t i = 0; i != 100u; ++i) mset.push_back(values[i]);
//Now check orderd invariant //Now check orderd invariant
multiset<MyClass>::const_iterator next(mset.cbegin()), it(next++); multiset<MyClass>::const_iterator next(mset.cbegin()), it(next++);
for(int i = 0; i < 99; ++i, ++it, ++next) assert(*it < *next); for(std::size_t i = 0; i < 99u; ++i, ++it, ++next) assert(*it < *next);
} }
{ //Now the correct order for the set is the reverse order { //Now the correct order for the set is the reverse order
//so let's push front all elements //so let's push front all elements
multiset<MyClass, compare< std::greater<MyClass> > > mset; multiset<MyClass, compare< std::greater<MyClass> > > mset;
for(int i = 0; i < 100; ++i) mset.push_front(values[i]); for(std::size_t i = 0; i < 100u; ++i) mset.push_front(values[i]);
//Now check orderd invariant //Now check orderd invariant
multiset<MyClass, compare< std::greater<MyClass> > >:: multiset<MyClass, compare< std::greater<MyClass> > >::
const_iterator next(mset.cbegin()), it(next++); const_iterator next(mset.cbegin()), it(next++);
for(int i = 0; i < 99; ++i, ++it, ++next) assert(*it > *next); for(std::size_t i = 0; i < 99u; ++i, ++it, ++next) assert(*it > *next);
} }
{ //Now push the first and the last and insert the rest { //Now push the first and the last and insert the rest
//before the last position using "insert_before" //before the last position using "insert_before"
@ -62,7 +62,7 @@ int main()
mset.insert_before(mset.begin(), values[0]); mset.insert_before(mset.begin(), values[0]);
multiset<MyClass>::const_iterator pos = multiset<MyClass>::const_iterator pos =
mset.insert_before(mset.end(), values[99]); mset.insert_before(mset.end(), values[99]);
for(int i = 1; i < 99; ++i) mset.insert_before(pos, values[i]); for(std::size_t i = 1; i < 99u; ++i) mset.insert_before(pos, values[i]);
//Now check orderd invariant //Now check orderd invariant
multiset<MyClass>::const_iterator next(mset.cbegin()), it(next++); multiset<MyClass>::const_iterator next(mset.cbegin()), it(next++);

2
example/doc_treap_algorithms.cpp
View File

@ -15,7 +15,7 @@
struct my_node struct my_node
{ {
my_node(int i = 0, unsigned int priority = 0) my_node(int i = 0, int priority = 0)
: prio_(priority), int_(i) : prio_(priority), int_(i)
{} {}
my_node *parent_, *left_, *right_; my_node *parent_, *left_, *right_;

2
example/doc_treap_set.cpp
View File

@ -66,7 +66,7 @@ int main()
//Create several MyClass objects, each one with a different value //Create several MyClass objects, each one with a different value
std::vector<MyClass> values; std::vector<MyClass> values;
for(int i = 0; i < 100; ++i) values.push_back(MyClass(i, (i % 10))); for(std::size_t i = 0; i < 100u; ++i) values.push_back(MyClass((int)i, unsigned(i % 10)));
BaseSet baseset; BaseSet baseset;
MemberMultiset membermultiset; MemberMultiset membermultiset;

78
include/boost/intrusive/detail/iterator.hpp
View File

@ -142,25 +142,25 @@ struct iterator_disable_if_tag_difference_type
// advance // advance
//////////////////// ////////////////////
template<class InputIt, class Distance> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
iterator_advance(InputIt& it, Distance n) iterator_advance(InputIt& it, typename iterator_traits<InputIt>::difference_type n)
{ {
while(n--) while(n--)
++it; ++it;
} }
template<class InputIt, class Distance> template<class InputIt>
typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
iterator_advance(InputIt& it, Distance n) iterator_advance(InputIt& it, typename iterator_traits<InputIt>::difference_type n)
{ {
while(n--) while(n--)
++it; ++it;
} }
template<class InputIt, class Distance> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
iterator_advance(InputIt& it, Distance n) iterator_advance(InputIt& it, typename iterator_traits<InputIt>::difference_type n)
{ {
for (; 0 < n; --n) for (; 0 < n; --n)
++it; ++it;
@ -175,37 +175,37 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
it += n; it += n;
} }
template<class InputIt, class Distance> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<InputIt, const boost::iterators::incrementable_traversal_tag&, const boost::iterators::single_pass_traversal_tag&>::type <InputIt, const boost::iterators::incrementable_traversal_tag&, const boost::iterators::single_pass_traversal_tag&>::type
iterator_advance(InputIt& it, Distance n) iterator_advance(InputIt& it, typename iterator_traits<InputIt>::difference_type n)
{ {
while(n--) while(n--)
++it; ++it;
} }
template<class InputIt, class Distance> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<InputIt, const boost::iterators::single_pass_traversal_tag &, const boost::iterators::forward_traversal_tag&>::type <InputIt, const boost::iterators::single_pass_traversal_tag &, const boost::iterators::forward_traversal_tag&>::type
iterator_advance(InputIt& it, Distance n) iterator_advance(InputIt& it, typename iterator_traits<InputIt>::difference_type n)
{ {
while(n--) while(n--)
++it; ++it;
} }
template<class InputIt, class Distance> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<InputIt, const boost::iterators::forward_traversal_tag&, const boost::iterators::bidirectional_traversal_tag&>::type <InputIt, const boost::iterators::forward_traversal_tag&, const boost::iterators::bidirectional_traversal_tag&>::type
iterator_advance(InputIt& it, Distance n) iterator_advance(InputIt& it, typename iterator_traits<InputIt>::difference_type n)
{ {
while(n--) while(n--)
++it; ++it;
} }
template<class InputIt, class Distance> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<InputIt, const boost::iterators::bidirectional_traversal_tag&, const boost::iterators::random_access_traversal_tag&>::type <InputIt, const boost::iterators::bidirectional_traversal_tag&, const boost::iterators::random_access_traversal_tag&>::type
iterator_advance(InputIt& it, Distance n) iterator_advance(InputIt& it, typename iterator_traits<InputIt>::difference_type n)
{ {
for (; 0 < n; --n) for (; 0 < n; --n)
++it; ++it;
@ -215,17 +215,24 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
class fake{}; class fake{};
template<class InputIt, class Distance> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<InputIt, const boost::iterators::random_access_traversal_tag&, const fake&>::type <InputIt, const boost::iterators::random_access_traversal_tag&, const fake&>::type
iterator_advance(InputIt& it, Distance n) iterator_advance(InputIt& it, typename iterator_traits<InputIt>::difference_type n)
{ {
it += n; it += n;
} }
//////////////////// template<class It>
// distance BOOST_INTRUSIVE_FORCEINLINE
//////////////////// void iterator_uadvance(It& it, typename iterator_traits<It>::size_type n)
{
(iterator_advance)(it, (typename iterator_traits<It>::difference_type)n);
}
////////////////////////////////////////
// iterator_distance
////////////////////////////////////////
template<class InputIt> inline template<class InputIt> inline
typename iterator_disable_if_tag_difference_type typename iterator_disable_if_tag_difference_type
<InputIt, std::random_access_iterator_tag>::type <InputIt, std::random_access_iterator_tag>::type
@ -248,6 +255,39 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
return off; return off;
} }
////////////////////////////////////////
// iterator_udistance
////////////////////////////////////////
template<class It>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<It>::size_type
iterator_udistance(It first, It last)
{
return (typename iterator_traits<It>::size_type)(iterator_distance)(first, last);
}
////////////////////////////////////////
// iterator_next
////////////////////////////////////////
template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iterator_traits<InputIt>::difference_type n)
{
(iterator_advance)(it, n);
return it;
}
template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iterator_traits<InputIt>::size_type n)
{
(iterator_advance)(it, n);
return it;
}
////////////////////////////////////////
// iterator_arrow_result
////////////////////////////////////////
template<class I> template<class I>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i) BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
{ return i.operator->(); } { return i.operator->(); }

6
include/boost/intrusive/detail/math.hpp
View File

@ -93,7 +93,7 @@ namespace detail {
struct builtin_clz_dispatch< ::boost::ulong_long_type > struct builtin_clz_dispatch< ::boost::ulong_long_type >
{ {
static ::boost::ulong_long_type call(::boost::ulong_long_type n) static ::boost::ulong_long_type call(::boost::ulong_long_type n)
{ return __builtin_clzll(n); } { return (::boost::ulong_long_type)__builtin_clzll(n); }
}; };
#endif #endif
@ -101,14 +101,14 @@ namespace detail {
struct builtin_clz_dispatch<unsigned long> struct builtin_clz_dispatch<unsigned long>
{ {
static unsigned long call(unsigned long n) static unsigned long call(unsigned long n)
{ return __builtin_clzl(n); } { return (unsigned long)__builtin_clzl(n); }
}; };
template<> template<>
struct builtin_clz_dispatch<unsigned int> struct builtin_clz_dispatch<unsigned int>
{ {
static unsigned int call(unsigned int n) static unsigned int call(unsigned int n)
{ return __builtin_clz(n); } { return (unsigned int)__builtin_clz(n); }
}; };
inline std::size_t floor_log2(std::size_t n) inline std::size_t floor_log2(std::size_t n)

2
include/boost/intrusive/detail/mpl.hpp
View File

@ -155,7 +155,7 @@ template <class T>\
struct TRAITS_PREFIX##_bool\ struct TRAITS_PREFIX##_bool\
{\ {\
template<bool Add>\ template<bool Add>\
struct two_or_three {yes_type _[2 + Add];};\ struct two_or_three {yes_type _[2u + (unsigned)Add];};\
template <class U> static yes_type test(...);\ template <class U> static yes_type test(...);\
template <class U> static two_or_three<U::TYPEDEF_TO_FIND> test (int);\ template <class U> static two_or_three<U::TYPEDEF_TO_FIND> test (int);\
static const std::size_t value = sizeof(test<T>(0));\ static const std::size_t value = sizeof(test<T>(0));\

143
include/boost/intrusive/detail/reverse_iterator.hpp
View File

@ -13,153 +13,16 @@
#ifndef BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP #ifndef BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
#define BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP #define BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
#ifndef BOOST_CONFIG_HPP #include <boost/move/detail/reverse_iterator.hpp>
# include <boost/config.hpp>
#endif
#if defined(BOOST_HAS_PRAGMA_ONCE)
# pragma once
#endif
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/detail/iterator.hpp>
#include <boost/intrusive/detail/mpl.hpp>
namespace boost { namespace boost {
namespace intrusive { namespace intrusive {
template<class It> using boost::movelib::reverse_iterator;
class reverse_iterator using boost::movelib::make_reverse_iterator;
{
public:
typedef typename boost::intrusive::iterator_traits<It>::pointer pointer;
typedef typename boost::intrusive::iterator_traits<It>::reference reference;
typedef typename boost::intrusive::iterator_traits<It>::difference_type difference_type;
typedef typename boost::intrusive::iterator_traits<It>::iterator_category iterator_category;
typedef typename boost::intrusive::iterator_traits<It>::value_type value_type;
typedef It iterator_type;
reverse_iterator()
: m_current() //Value initialization to achieve "null iterators" (N3644)
{}
explicit reverse_iterator(It r)
: m_current(r)
{}
reverse_iterator(const reverse_iterator& r)
: m_current(r.base())
{}
template<class OtherIt>
reverse_iterator( const reverse_iterator<OtherIt>& r
, typename boost::intrusive::detail::enable_if_convertible<OtherIt, It>::type* =0
)
: m_current(r.base())
{}
reverse_iterator & operator=( const reverse_iterator& r)
{ m_current = r.base(); return *this; }
template<class OtherIt>
typename boost::intrusive::detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
operator=( const reverse_iterator<OtherIt>& r)
{ m_current = r.base(); return *this; }
It base() const
{ return m_current; }
reference operator*() const
{
It temp(m_current);
--temp;
reference r = *temp;
return r;
}
pointer operator->() const
{
It temp(m_current);
--temp;
return iterator_arrow_result(temp);
}
reference operator[](difference_type off) const
{
return this->m_current[-off - 1];
}
reverse_iterator& operator++()
{
--m_current;
return *this;
}
reverse_iterator operator++(int)
{
reverse_iterator temp((*this));
--m_current;
return temp;
}
reverse_iterator& operator--()
{
++m_current;
return *this;
}
reverse_iterator operator--(int)
{
reverse_iterator temp((*this));
++m_current;
return temp;
}
friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
{ return l.m_current == r.m_current; }
friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
{ return l.m_current != r.m_current; }
friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
{ return l.m_current > r.m_current; }
friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
{ return l.m_current >= r.m_current; }
friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
{ return l.m_current < r.m_current; }
friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
{ return l.m_current <= r.m_current; }
reverse_iterator& operator+=(difference_type off)
{ m_current -= off; return *this; }
reverse_iterator& operator-=(difference_type off)
{ m_current += off; return *this; }
friend reverse_iterator operator+(reverse_iterator l, difference_type off)
{ return (l += off); }
friend reverse_iterator operator+(difference_type off, reverse_iterator r)
{ return (r += off); }
friend reverse_iterator operator-(reverse_iterator l, difference_type off)
{ return (l-= off); }
friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
{ return r.m_current - l.m_current; }
private:
It m_current; // the wrapped iterator
};
} //namespace intrusive { } //namespace intrusive {
} //namespace boost { } //namespace boost {
#include <boost/intrusive/detail/config_end.hpp>
#endif //BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP #endif //BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP

170
include/boost/intrusive/hashtable.hpp
View File

@ -314,20 +314,20 @@ template <class T>
struct store_hash_is_true struct store_hash_is_true
{ {
template<bool Add> template<bool Add>
struct two_or_three {yes_type _[2 + Add];}; struct two_or_three {yes_type _[2u + (unsigned)Add];};
template <class U> static yes_type test(...); template <class U> static yes_type test(...);
template <class U> static two_or_three<U::store_hash> test (int); template <class U> static two_or_three<U::store_hash> test (int);
static const bool value = sizeof(test<T>(0)) > sizeof(yes_type)*2; static const bool value = sizeof(test<T>(0)) > sizeof(yes_type)*2u;
}; };
template <class T> template <class T>
struct optimize_multikey_is_true struct optimize_multikey_is_true
{ {
template<bool Add> template<bool Add>
struct two_or_three {yes_type _[2 + Add];}; struct two_or_three {yes_type _[2u + (unsigned)Add];};
template <class U> static yes_type test(...); template <class U> static yes_type test(...);
template <class U> static two_or_three<U::optimize_multikey> test (int); template <class U> static two_or_three<U::optimize_multikey> test (int);
static const bool value = sizeof(test<T>(0)) > sizeof(yes_type)*2; static const bool value = sizeof(test<T>(0)) > sizeof(yes_type)*2u;
}; };
struct insert_commit_data_impl struct insert_commit_data_impl
@ -735,18 +735,22 @@ struct bucket_plus_vtraits
BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_bucket_pointer() const BOOST_NOEXCEPT BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_bucket_pointer() const BOOST_NOEXCEPT
{ return this->priv_bucket_traits().bucket_begin(); } { return this->priv_bucket_traits().bucket_begin(); }
template<class SizeType> std::size_t priv_bucket_count() const BOOST_NOEXCEPT
SizeType priv_bucket_count() const BOOST_NOEXCEPT
{ {
const std::size_t bc = this->priv_bucket_traits().bucket_count(); const std::size_t bc = this->priv_bucket_traits().bucket_count();
BOOST_INTRUSIVE_INVARIANT_ASSERT(sizeof(SizeType) >= sizeof(std::size_t) || bc <= SizeType(-1)); return bc;
return static_cast<SizeType>(bc); }
BOOST_INTRUSIVE_FORCEINLINE bucket_type &priv_bucket(std::size_t n) const BOOST_NOEXCEPT
{
BOOST_INTRUSIVE_INVARIANT_ASSERT(n < this->priv_bucket_traits().bucket_count());
return priv_bucket_pointer()[std::ptrdiff_t(n)];
} }
BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_invalid_bucket() const BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_invalid_bucket() const
{ {
const bucket_traits &rbt = this->priv_bucket_traits(); const bucket_traits &rbt = this->priv_bucket_traits();
return rbt.bucket_begin() + rbt.bucket_count(); return rbt.bucket_begin() + std::ptrdiff_t(rbt.bucket_count());
} }
BOOST_INTRUSIVE_FORCEINLINE siterator priv_invalid_local_it() const BOOST_INTRUSIVE_FORCEINLINE siterator priv_invalid_local_it() const
@ -849,7 +853,7 @@ struct bucket_plus_vtraits
std::size_t num_erased(0); std::size_t num_erased(0);
siterator last_step_before_it; siterator last_step_before_it;
if(first_bucket != last_bucket){ if(first_bucket != last_bucket){
bucket_type *b = (&this->priv_bucket_pointer()[0]); bucket_type *b = &this->priv_bucket(0);
num_erased += this->priv_erase_from_single_bucket num_erased += this->priv_erase_from_single_bucket
(b[first_bucket], before_first_it, b[first_bucket].end(), node_disposer, optimize_multikey_tag); (b[first_bucket], before_first_it, b[first_bucket].end(), node_disposer, optimize_multikey_tag);
for(std::size_t i = 0, n = (last_bucket - first_bucket - 1); i != n; ++i){ for(std::size_t i = 0, n = (last_bucket - first_bucket - 1); i != n; ++i){
@ -861,7 +865,7 @@ struct bucket_plus_vtraits
last_step_before_it = before_first_it; last_step_before_it = before_first_it;
} }
num_erased += this->priv_erase_from_single_bucket num_erased += this->priv_erase_from_single_bucket
(this->priv_bucket_pointer()[last_bucket], last_step_before_it, last_it, node_disposer, optimize_multikey_tag); (this->priv_bucket(last_bucket), last_step_before_it, last_it, node_disposer, optimize_multikey_tag);
return num_erased; return num_erased;
} }
@ -917,23 +921,25 @@ struct bucket_plus_vtraits
std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::true_) //optimize multikey std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::true_) //optimize multikey
{ {
const bucket_ptr f(this->priv_bucket_pointer()), l(f + this->template priv_bucket_count<std::size_t>() - 1); const bucket_type &f = this->priv_bucket(0u);
const bucket_type &l = this->priv_bucket(this->priv_bucket_count() - 1u);
slist_node_ptr bb = group_functions_t::get_bucket_before_begin slist_node_ptr bb = group_functions_t::get_bucket_before_begin
( f->end().pointed_node() ( f.end().pointed_node()
, l->end().pointed_node() , l.end().pointed_node()
, detail::dcast_bucket_ptr<node>(it.pointed_node())); , detail::dcast_bucket_ptr<node>(it.pointed_node()));
//Now get the bucket_impl from the iterator //Now get the bucket_impl from the iterator
const bucket_type &b = static_cast<const bucket_type&> const bucket_type &b = static_cast<const bucket_type&>
(bucket_type::slist_type::container_from_end_iterator(bucket_type::s_iterator_to(*bb))); (bucket_type::slist_type::container_from_end_iterator(bucket_type::s_iterator_to(*bb)));
//Now just calculate the index b has in the bucket array //Now just calculate the index b has in the bucket array
return static_cast<std::size_t>(&b - &*f); return static_cast<std::size_t>(&b - &f);
} }
std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::false_) //NO optimize multikey std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::false_) //NO optimize multikey
{ {
bucket_ptr f(this->priv_bucket_pointer()), l(f + this->template priv_bucket_count<std::size_t>() - 1); const bucket_type &f = this->priv_bucket(0u);
slist_node_ptr first_ptr(f->cend().pointed_node()) const bucket_type &l = this->priv_bucket(this->priv_bucket_count() - 1u);
, last_ptr(l->cend().pointed_node()); slist_node_ptr first_ptr(f.cend().pointed_node())
, last_ptr (l.cend().pointed_node());
//The end node is embedded in the singly linked list: //The end node is embedded in the singly linked list:
//iterate until we reach it. //iterate until we reach it.
@ -946,7 +952,7 @@ struct bucket_plus_vtraits
(bucket_type::container_from_end_iterator(it)); (bucket_type::container_from_end_iterator(it));
//Now just calculate the index b has in the bucket array //Now just calculate the index b has in the bucket array
return static_cast<std::size_t>(&b - &*f); return static_cast<std::size_t>(&b - &f);
} }
BOOST_INTRUSIVE_FORCEINLINE static std::size_t priv_stored_hash(slist_node_ptr n, detail::true_) //store_hash BOOST_INTRUSIVE_FORCEINLINE static std::size_t priv_stored_hash(slist_node_ptr n, detail::true_) //store_hash
@ -1168,9 +1174,9 @@ struct bucket_hash_equal_t
siterator priv_begin() const siterator priv_begin() const
{ {
std::size_t n = 0; std::size_t n = 0;
std::size_t bucket_cnt = this->bucket_hash_type:: template priv_bucket_count<std::size_t>(); std::size_t bucket_cnt = this->bucket_hash_type::priv_bucket_count();
for (n = 0; n < bucket_cnt; ++n){ for (n = 0; n < bucket_cnt; ++n){
bucket_type &b = this->bucket_hash_type::priv_bucket_pointer()[n]; bucket_type &b = this->bucket_hash_type::priv_bucket(n);
if(!b.empty()){ if(!b.empty()){
return b.begin(); return b.begin();
} }
@ -1233,7 +1239,7 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
{ cached_begin_ = p; } { cached_begin_ = p; }
BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_get_cache_bucket_num() BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_get_cache_bucket_num()
{ return this->cached_begin_ - this->bucket_hash_type::priv_bucket_pointer(); } { return std::size_t(this->cached_begin_ - this->bucket_hash_type::priv_bucket_pointer()); }
BOOST_INTRUSIVE_FORCEINLINE void priv_initialize_cache() BOOST_INTRUSIVE_FORCEINLINE void priv_initialize_cache()
{ this->cached_begin_ = this->bucket_hash_type::priv_invalid_bucket(); } { this->cached_begin_ = this->bucket_hash_type::priv_invalid_bucket(); }
@ -1255,7 +1261,8 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
void priv_insertion_update_cache(std::size_t insertion_bucket) void priv_insertion_update_cache(std::size_t insertion_bucket)
{ {
bucket_ptr p = this->bucket_hash_type::priv_bucket_pointer() + insertion_bucket; BOOST_INTRUSIVE_INVARIANT_ASSERT(insertion_bucket < this->bucket_hash_type::priv_bucket_count());
bucket_ptr p = this->bucket_hash_type::priv_bucket_pointer() + std::ptrdiff_t(insertion_bucket);
if(p < this->cached_begin_){ if(p < this->cached_begin_){
this->cached_begin_ = p; this->cached_begin_ = p;
} }
@ -1272,8 +1279,8 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
//If the last bucket is the end, the cache must be updated //If the last bucket is the end, the cache must be updated
//to the last position if all //to the last position if all
if(this->priv_get_cache_bucket_num() == first_bucket_num && if(this->priv_get_cache_bucket_num() == first_bucket_num &&
this->bucket_hash_type::priv_bucket_pointer()[first_bucket_num].empty() ){ this->bucket_hash_type::priv_bucket(first_bucket_num).empty() ){
this->priv_set_cache(this->bucket_hash_type::priv_bucket_pointer() + last_bucket_num); this->priv_set_cache(this->bucket_hash_type::priv_bucket_pointer() + std::ptrdiff_t(last_bucket_num));
this->priv_erasure_update_cache(); this->priv_erasure_update_cache();
} }
} }
@ -1281,8 +1288,8 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
void priv_erasure_update_cache() void priv_erasure_update_cache()
{ {
if(this->cached_begin_ != this->bucket_hash_type::priv_invalid_bucket()){ if(this->cached_begin_ != this->bucket_hash_type::priv_invalid_bucket()){
std::size_t current_n = this->priv_get_cache() - this->bucket_hash_type::priv_bucket_pointer(); std::size_t current_n = std::size_t(this->priv_get_cache() - this->bucket_hash_type::priv_bucket_pointer());
for( const std::size_t num_buckets = this->bucket_hash_type::template priv_bucket_count<std::size_t>() for( const std::size_t num_buckets = this->bucket_hash_type::priv_bucket_count()
; current_n < num_buckets ; current_n < num_buckets
; ++current_n, ++this->priv_get_cache()){ ; ++current_n, ++this->priv_get_cache()){
if(!this->priv_get_cache()->empty()){ if(!this->priv_get_cache()->empty()){
@ -1441,11 +1448,10 @@ struct hashdata_internal
void priv_clear_buckets() void priv_clear_buckets()
{ {
const std::size_t cache_num = std::size_t(this->priv_get_cache() - this->internal_type::priv_bucket_pointer());
this->internal_type::priv_clear_buckets this->internal_type::priv_clear_buckets
( this->priv_get_cache() ( this->priv_get_cache()
, this->internal_type::template priv_bucket_count<size_type>() , this->internal_type::priv_bucket_count() - cache_num);
- (this->priv_get_cache()
- this->internal_type::priv_bucket_pointer()));
} }
void priv_clear_buckets_and_cache() void priv_clear_buckets_and_cache()
@ -1458,7 +1464,7 @@ struct hashdata_internal
{ {
this->internal_type::priv_clear_buckets this->internal_type::priv_clear_buckets
( this->internal_type::priv_bucket_pointer() ( this->internal_type::priv_bucket_pointer()
, this->internal_type::template priv_bucket_count<size_type>()); , this->internal_type::priv_bucket_count());
this->priv_initialize_cache(); this->priv_initialize_cache();
} }
@ -1525,16 +1531,16 @@ struct hashdata_internal
} }
BOOST_INTRUSIVE_FORCEINLINE size_type bucket_count() const BOOST_NOEXCEPT BOOST_INTRUSIVE_FORCEINLINE size_type bucket_count() const BOOST_NOEXCEPT
{ return this->template priv_bucket_count<size_type>(); } { return size_type(this->priv_bucket_count()); }
BOOST_INTRUSIVE_FORCEINLINE size_type bucket_size(size_type n) const BOOST_NOEXCEPT BOOST_INTRUSIVE_FORCEINLINE size_type bucket_size(size_type n) const BOOST_NOEXCEPT
{ return (size_type)this->priv_bucket_pointer()[n].size(); } { return (size_type)this->priv_bucket(n).size(); }
BOOST_INTRUSIVE_FORCEINLINE bucket_ptr bucket_pointer() const BOOST_NOEXCEPT BOOST_INTRUSIVE_FORCEINLINE bucket_ptr bucket_pointer() const BOOST_NOEXCEPT
{ return this->priv_bucket_pointer(); } { return this->priv_bucket_pointer(); }
BOOST_INTRUSIVE_FORCEINLINE local_iterator begin(size_type n) BOOST_NOEXCEPT BOOST_INTRUSIVE_FORCEINLINE local_iterator begin(size_type n) BOOST_NOEXCEPT
{ return local_iterator(this->priv_bucket_pointer()[n].begin(), this->priv_value_traits_ptr()); } { return local_iterator(this->priv_bucket(n).begin(), this->priv_value_traits_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE const_local_iterator begin(size_type n) const BOOST_NOEXCEPT BOOST_INTRUSIVE_FORCEINLINE const_local_iterator begin(size_type n) const BOOST_NOEXCEPT
{ return this->cbegin(n); } { return this->cbegin(n); }
@ -1552,7 +1558,7 @@ struct hashdata_internal
const_local_iterator cbegin(size_type n) const BOOST_NOEXCEPT const_local_iterator cbegin(size_type n) const BOOST_NOEXCEPT
{ {
return const_local_iterator return const_local_iterator
( pointer_traits<bucket_ptr>::const_cast_from(this->priv_bucket_pointer())[n].begin() ( this->priv_bucket(n).begin()
, this->priv_value_traits_ptr()); , this->priv_value_traits_ptr());
} }
@ -1560,7 +1566,7 @@ struct hashdata_internal
using internal_type::cend; using internal_type::cend;
local_iterator end(size_type n) BOOST_NOEXCEPT local_iterator end(size_type n) BOOST_NOEXCEPT
{ return local_iterator(this->priv_bucket_pointer()[n].end(), this->priv_value_traits_ptr()); } { return local_iterator(this->priv_bucket(n).end(), this->priv_value_traits_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE const_local_iterator end(size_type n) const BOOST_NOEXCEPT BOOST_INTRUSIVE_FORCEINLINE const_local_iterator end(size_type n) const BOOST_NOEXCEPT
{ return this->cend(n); } { return this->cend(n); }
@ -1568,7 +1574,7 @@ struct hashdata_internal
const_local_iterator cend(size_type n) const BOOST_NOEXCEPT const_local_iterator cend(size_type n) const BOOST_NOEXCEPT
{ {
return const_local_iterator return const_local_iterator
( pointer_traits<bucket_ptr>::const_cast_from(this->priv_bucket_pointer())[n].end() ( this->priv_bucket(n).end()
, this->priv_value_traits_ptr()); , this->priv_value_traits_ptr());
} }
@ -1819,7 +1825,7 @@ class hashtable_impl
//Check power of two bucket array if the option is activated //Check power of two bucket array if the option is activated
BOOST_INTRUSIVE_INVARIANT_ASSERT BOOST_INTRUSIVE_INVARIANT_ASSERT
(!power_2_buckets || (0 == (bucket_sz & (bucket_sz-1)))); (!power_2_buckets || (0 == (bucket_sz & (bucket_sz-1))));
this->priv_split_traits().set_size(bucket_sz>>1); this->priv_split_traits().set_size(size_type(bucket_sz>>1u));
} }
//! <b>Requires</b>: buckets must not be being used by any other resource //! <b>Requires</b>: buckets must not be being used by any other resource
@ -1852,7 +1858,7 @@ class hashtable_impl
//Check power of two bucket array if the option is activated //Check power of two bucket array if the option is activated
BOOST_INTRUSIVE_INVARIANT_ASSERT BOOST_INTRUSIVE_INVARIANT_ASSERT
(!power_2_buckets || (0 == (bucket_sz & (bucket_sz-1)))); (!power_2_buckets || (0 == (bucket_sz & (bucket_sz-1))));
this->priv_split_traits().set_size(bucket_sz>>1); this->priv_split_traits().set_size(size_type(bucket_sz>>1u));
//Now insert //Now insert
if(unique) if(unique)
this->insert_unique(b, e); this->insert_unique(b, e);
@ -2000,13 +2006,14 @@ class hashtable_impl
BOOST_IF_CONSTEXPR(constant_time_size) BOOST_IF_CONSTEXPR(constant_time_size)
return this->priv_size_traits().get_size(); return this->priv_size_traits().get_size();
else{ else{
size_type len = 0; std::size_t len = 0;
size_type bucket_cnt = this->bucket_count(); std::size_t bucket_cnt = this->bucket_count();
const bucket_type *b = boost::movelib::to_raw_pointer(this->priv_bucket_pointer()); const bucket_type *b = boost::movelib::to_raw_pointer(this->priv_bucket_pointer());
for (size_type n = 0; n < bucket_cnt; ++n, ++b){ for (std::size_t n = 0; n < bucket_cnt; ++n, ++b){
len += (size_type)b->size(); len += b->size();
} }
return len; BOOST_INTRUSIVE_INVARIANT_ASSERT((len <= SizeType(-1)));
return size_type(len);
} }
} }
@ -2269,7 +2276,7 @@ class hashtable_impl
iterator insert_unique_commit(reference value, const insert_commit_data &commit_data) BOOST_NOEXCEPT iterator insert_unique_commit(reference value, const insert_commit_data &commit_data) BOOST_NOEXCEPT
{ {
size_type bucket_num = this->priv_hash_to_bucket(commit_data.hash); size_type bucket_num = this->priv_hash_to_bucket(commit_data.hash);
bucket_type &b = this->priv_bucket_pointer()[bucket_num]; bucket_type &b = this->priv_bucket(bucket_num);
this->priv_size_traits().increment(); this->priv_size_traits().increment();
node_ptr const n = pointer_traits<node_ptr>::pointer_to(this->priv_value_to_node(value)); node_ptr const n = pointer_traits<node_ptr>::pointer_to(this->priv_value_to_node(value));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(n)); BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(n));
@ -2360,7 +2367,7 @@ class hashtable_impl
//Get the bucket number and local iterator for both iterators //Get the bucket number and local iterator for both iterators
siterator const first_local_it(i.slist_it()); siterator const first_local_it(i.slist_it());
size_type const first_bucket_num = this->priv_get_bucket_num(first_local_it); size_type const first_bucket_num = this->priv_get_bucket_num(first_local_it);
this->priv_erase_node(this->priv_bucket_pointer()[first_bucket_num], first_local_it, make_node_disposer(disposer), optimize_multikey_t()); this->priv_erase_node(this->priv_bucket(first_bucket_num), first_local_it, make_node_disposer(disposer), optimize_multikey_t());
this->priv_size_traits().decrement(); this->priv_size_traits().decrement();
this->priv_erasure_update_cache_range(first_bucket_num, first_bucket_num); this->priv_erasure_update_cache_range(first_bucket_num, first_bucket_num);
} }
@ -2385,17 +2392,16 @@ class hashtable_impl
siterator first_local_it(b.slist_it()); siterator first_local_it(b.slist_it());
size_type first_bucket_num = this->priv_get_bucket_num(first_local_it); size_type first_bucket_num = this->priv_get_bucket_num(first_local_it);
const bucket_ptr buck_ptr = this->priv_bucket_pointer();
siterator before_first_local_it siterator before_first_local_it
= this->priv_get_previous(buck_ptr[first_bucket_num], first_local_it); = this->priv_get_previous(this->priv_bucket(first_bucket_num), first_local_it);
size_type last_bucket_num; size_type last_bucket_num;
siterator last_local_it; siterator last_local_it;
//For the end iterator, we will assign the end iterator //For the end iterator, we will assign the end iterator
//of the last bucket //of the last bucket
if(e == this->end()){ if(e == this->end()){
last_bucket_num = this->bucket_count() - 1; last_bucket_num = size_type(this->bucket_count() - 1u);
last_local_it = buck_ptr[last_bucket_num].end(); last_local_it = this->priv_bucket(last_bucket_num).end();
} }
else{ else{
last_local_it = e.slist_it(); last_local_it = e.slist_it();
@ -2404,7 +2410,7 @@ class hashtable_impl
size_type const num_erased = (size_type)this->priv_erase_node_range size_type const num_erased = (size_type)this->priv_erase_node_range
( before_first_local_it, first_bucket_num, last_local_it, last_bucket_num ( before_first_local_it, first_bucket_num, last_local_it, last_bucket_num
, make_node_disposer(disposer), optimize_multikey_t()); , make_node_disposer(disposer), optimize_multikey_t());
this->priv_size_traits().set_size(this->priv_size_traits().get_size()-num_erased); this->priv_size_traits().set_size(size_type(this->priv_size_traits().get_size()-num_erased));
this->priv_erasure_update_cache_range(first_bucket_num, last_bucket_num); this->priv_erasure_update_cache_range(first_bucket_num, last_bucket_num);
} }
} }
@ -2457,10 +2463,10 @@ class hashtable_impl
if(success){ if(success){
if(optimize_multikey){ if(optimize_multikey){
cnt = this->priv_erase_from_single_bucket cnt = this->priv_erase_from_single_bucket
(this->priv_bucket_pointer()[bucket_num], prev, ++(priv_last_in_group)(it), make_node_disposer(disposer), optimize_multikey_t()); (this->priv_bucket(bucket_num), prev, ++(priv_last_in_group)(it), make_node_disposer(disposer), optimize_multikey_t());
} }
else{ else{
bucket_type &b = this->priv_bucket_pointer()[bucket_num]; bucket_type &b = this->priv_bucket(bucket_num);
siterator const end_sit = b.end(); siterator const end_sit = b.end();
do{ do{
++cnt; ++cnt;
@ -2470,7 +2476,7 @@ class hashtable_impl
(this->priv_value_from_slist_node(it.pointed_node()), h, key, equal_func)); (this->priv_value_from_slist_node(it.pointed_node()), h, key, equal_func));
bucket_type::s_erase_after_and_dispose(prev, it, make_node_disposer(disposer)); bucket_type::s_erase_after_and_dispose(prev, it, make_node_disposer(disposer));
} }
this->priv_size_traits().set_size(this->priv_size_traits().get_size()-cnt); this->priv_size_traits().set_size(size_type(this->priv_size_traits().get_size()-cnt));
this->priv_erasure_update_cache(); this->priv_erasure_update_cache();
} }
@ -2981,34 +2987,33 @@ class hashtable_impl
{ {
//This function is only available for containers with incremental hashing //This function is only available for containers with incremental hashing
BOOST_STATIC_ASSERT(( incremental && power_2_buckets )); BOOST_STATIC_ASSERT(( incremental && power_2_buckets ));
const size_type split_idx = this->priv_split_traits().get_size(); const std::size_t split_idx = this->priv_split_traits().get_size();
const size_type bucket_cnt = this->bucket_count(); const std::size_t bucket_cnt = this->bucket_count();
const bucket_ptr buck_ptr = this->priv_bucket_pointer();
bool ret = false; bool ret = false;
if(grow){ if(grow){
//Test if the split variable can be changed //Test if the split variable can be changed
if((ret = split_idx < bucket_cnt)){ if((ret = split_idx < bucket_cnt)){
const size_type bucket_to_rehash = split_idx - bucket_cnt/2; const std::size_t bucket_to_rehash = split_idx - bucket_cnt/2u;
bucket_type &old_bucket = buck_ptr[bucket_to_rehash]; bucket_type &old_bucket = this->priv_bucket(bucket_to_rehash);
this->priv_split_traits().increment(); this->priv_split_traits().increment();
//Anti-exception stuff: if an exception is thrown while //Anti-exception stuff: if an exception is thrown while
//moving elements from old_bucket to the target bucket, all moved //moving elements from old_bucket to the target bucket, all moved
//elements are moved back to the original one. //elements are moved back to the original one.
detail::incremental_rehash_rollback<bucket_type, split_traits> rollback detail::incremental_rehash_rollback<bucket_type, split_traits> rollback
( buck_ptr[split_idx], old_bucket, this->priv_split_traits()); ( this->priv_bucket(split_idx), old_bucket, this->priv_split_traits());
for( siterator before_i(old_bucket.before_begin()), i(old_bucket.begin()), end_sit(old_bucket.end()) for( siterator before_i(old_bucket.before_begin()), i(old_bucket.begin()), end_sit(old_bucket.end())
; i != end_sit; i = before_i, ++i){ ; i != end_sit; i = before_i, ++i){
const value_type &v = this->priv_value_from_slist_node(i.pointed_node()); const value_type &v = this->priv_value_from_slist_node(i.pointed_node());
const std::size_t hash_value = this->priv_stored_or_compute_hash(v, store_hash_t()); const std::size_t hash_value = this->priv_stored_or_compute_hash(v, store_hash_t());
const size_type new_n = this->priv_hash_to_bucket(hash_value); const std::size_t new_n = this->priv_hash_to_bucket(hash_value);
siterator const last = (priv_last_in_group)(i); siterator const last = (priv_last_in_group)(i);
if(new_n == bucket_to_rehash){ if(new_n == bucket_to_rehash){
before_i = last; before_i = last;
} }
else{ else{
bucket_type &new_b = buck_ptr[new_n]; bucket_type &new_b = this->priv_bucket(new_n);
new_b.splice_after(new_b.before_begin(), old_bucket, before_i, last); new_b.splice_after(new_b.before_begin(), old_bucket, before_i, last);
} }
} }
@ -3016,10 +3021,10 @@ class hashtable_impl
this->priv_erasure_update_cache(); this->priv_erasure_update_cache();
} }
} }
else if((ret = split_idx > bucket_cnt/2)){ //!grow else if((ret = split_idx > bucket_cnt/2u)){ //!grow
const size_type target_bucket_num = size_type(split_idx - 1u - bucket_cnt/2u); const std::size_t target_bucket_num = split_idx - 1u - bucket_cnt/2u;
bucket_type &target_bucket = buck_ptr[target_bucket_num]; bucket_type &target_bucket = this->priv_bucket(target_bucket_num);
bucket_type &source_bucket = buck_ptr[split_idx-1]; bucket_type &source_bucket = this->priv_bucket(split_idx-1u);
target_bucket.splice_after(target_bucket.cbefore_begin(), source_bucket); target_bucket.splice_after(target_bucket.cbefore_begin(), source_bucket);
this->priv_split_traits().decrement(); this->priv_split_traits().decrement();
this->priv_insertion_update_cache(target_bucket_num); this->priv_insertion_update_cache(target_bucket_num);
@ -3068,8 +3073,8 @@ class hashtable_impl
this->priv_bucket_traits() = new_bucket_traits; this->priv_bucket_traits() = new_bucket_traits;
if(new_bucket_traits.bucket_begin() != old_buckets){ if(new_bucket_traits.bucket_begin() != old_buckets){
for(size_type n = ini_n; n < split_idx; ++n){ for(size_type n = ini_n; n < split_idx; ++n){
bucket_type &new_bucket = new_bucket_traits.bucket_begin()[n]; bucket_type &new_bucket = new_bucket_traits.bucket_begin()[difference_type(n)];
bucket_type &old_bucket = old_buckets[n]; bucket_type &old_bucket = old_buckets[difference_type(n)];
new_bucket.splice_after(new_bucket.cbefore_begin(), old_bucket); new_bucket.splice_after(new_bucket.cbefore_begin(), old_bucket);
} }
//Put cache to safe position //Put cache to safe position
@ -3198,7 +3203,7 @@ class hashtable_impl
//Iterate through nodes //Iterate through nodes
for(; n < old_bucket_count; ++n){ for(; n < old_bucket_count; ++n){
bucket_type &old_bucket = old_buckets[n]; bucket_type &old_bucket = old_buckets[difference_type(n)];
if(!fast_shrink){ if(!fast_shrink){
for( siterator before_i(old_bucket.before_begin()), i(old_bucket.begin()), end_sit(old_bucket.end()) for( siterator before_i(old_bucket.before_begin()), i(old_bucket.begin()), end_sit(old_bucket.end())
; i != end_sit ; i != end_sit
@ -3231,7 +3236,7 @@ class hashtable_impl
before_i = last; before_i = last;
} }
else{ else{
bucket_type &new_b = new_buckets[new_n]; bucket_type &new_b = new_buckets[difference_type(new_n)];
new_b.splice_after(new_b.before_begin(), old_bucket, before_i, last); new_b.splice_after(new_b.before_begin(), old_bucket, before_i, last);
} }
} }
@ -3241,7 +3246,7 @@ class hashtable_impl
<power_2_buckets, incremental>(n, new_bucket_count, new_bucket_count); <power_2_buckets, incremental>(n, new_bucket_count, new_bucket_count);
if(cache_begin && new_n < new_first_bucket_num) if(cache_begin && new_n < new_first_bucket_num)
new_first_bucket_num = new_n; new_first_bucket_num = new_n;
bucket_type &new_b = new_buckets[new_n]; bucket_type &new_b = new_buckets[difference_type(new_n)];
new_b.splice_after( new_b.before_begin() new_b.splice_after( new_b.before_begin()
, old_bucket , old_bucket
, old_bucket.before_begin() , old_bucket.before_begin()
@ -3311,7 +3316,7 @@ class hashtable_impl
//as this is an unordered container. So use minimal insertion code //as this is an unordered container. So use minimal insertion code
//std::size_t const hash_value = this->priv_stored_or_compute_hash(src_ref, store_hash_t());; //std::size_t const hash_value = this->priv_stored_or_compute_hash(src_ref, store_hash_t());;
//size_type const bucket_number = this->priv_hash_to_bucket(hash_value); //size_type const bucket_number = this->priv_hash_to_bucket(hash_value);
bucket_type &cur_bucket = this->priv_bucket_pointer()[bucket_number]; bucket_type &cur_bucket = this->priv_bucket(bucket_number);
siterator const prev(cur_bucket.before_begin()); siterator const prev(cur_bucket.before_begin());
//Just check if the cloned node is equal to the first inserted value in the new bucket //Just check if the cloned node is equal to the first inserted value in the new bucket
//as equal src values were contiguous and they should be already inserted in the //as equal src values were contiguous and they should be already inserted in the
@ -3328,22 +3333,20 @@ class hashtable_impl
//First clone the first ones //First clone the first ones
const size_type src_bucket_count = src.bucket_count(); const size_type src_bucket_count = src.bucket_count();
const size_type dst_bucket_count = this->bucket_count(); const size_type dst_bucket_count = this->bucket_count();
const bucket_ptr src_buckets = src.priv_bucket_pointer();
const bucket_ptr dst_buckets = this->priv_bucket_pointer();
size_type constructed = 0; size_type constructed = 0;
typedef node_cast_adaptor< detail::node_disposer<Disposer, value_traits, CircularSListAlgorithms> typedef node_cast_adaptor< detail::node_disposer<Disposer, value_traits, CircularSListAlgorithms>
, slist_node_ptr, node_ptr > NodeDisposer; , slist_node_ptr, node_ptr > NodeDisposer;
NodeDisposer node_disp(disposer, &this->priv_value_traits()); NodeDisposer node_disp(disposer, &this->priv_value_traits());
detail::exception_array_disposer<bucket_type, NodeDisposer, size_type> detail::exception_array_disposer<bucket_type, NodeDisposer, size_type>
rollback(dst_buckets[0], node_disp, constructed); rollback(this->priv_bucket(0), node_disp, constructed);
//Now insert the remaining ones using the modulo trick //Now insert the remaining ones using the modulo trick
for( //"constructed" already initialized for( //"constructed" already initialized
; constructed < src_bucket_count ; constructed < src_bucket_count
; ++constructed){ ; ++constructed){
//Since incremental hashing can't be structurally copied, avoid hash_to_bucket_split //Since incremental hashing can't be structurally copied, avoid hash_to_bucket_split
const size_type new_n = (size_type) detail::hash_to_bucket(constructed, dst_bucket_count, detail::bool_<power_2_buckets>()); const size_type new_n = (size_type) detail::hash_to_bucket(constructed, dst_bucket_count, detail::bool_<power_2_buckets>());
bucket_type &src_b = src_buckets[constructed]; bucket_type &src_b = src.priv_bucket(constructed);
for( siterator b(src_b.begin()), e(src_b.end()); b != e; ++b){ for( siterator b(src_b.begin()), e(src_b.end()); b != e; ++b){
slist_node_ptr const n(b.pointed_node()); slist_node_ptr const n(b.pointed_node());
typedef typename detail::if_c typedef typename detail::if_c
@ -3415,7 +3418,7 @@ class hashtable_impl
( const KeyType &key, KeyEqual equal_func, size_type &bucket_number, const std::size_t h, siterator &previt) const ( const KeyType &key, KeyEqual equal_func, size_type &bucket_number, const std::size_t h, siterator &previt) const
{ {
bucket_number = this->priv_hash_to_bucket(h); bucket_number = this->priv_hash_to_bucket(h);
bucket_type &b = this->priv_bucket_pointer()[bucket_number]; bucket_type &b = this->priv_bucket(bucket_number);
previt = b.before_begin(); previt = b.before_begin();
siterator it = previt; siterator it = previt;
siterator const endit = b.end(); siterator const endit = b.end();
@ -3438,7 +3441,7 @@ class hashtable_impl
, size_type &found_bucket , size_type &found_bucket
, size_type &cnt) const , size_type &cnt) const
{ {
size_type internal_cnt = 0; std::size_t internal_cnt = 0;
//Let's see if the element is present //Let's see if the element is present
siterator prev; siterator prev;
@ -3452,12 +3455,12 @@ class hashtable_impl
found_bucket = n_bucket; found_bucket = n_bucket;
//If it's present, find the first that it's not equal in //If it's present, find the first that it's not equal in
//the same bucket //the same bucket
bucket_type &b = this->priv_bucket_pointer()[n_bucket]; bucket_type &b = this->priv_bucket(n_bucket);
siterator it = to_return.first; siterator it = to_return.first;
++internal_cnt; //At least one is found ++internal_cnt; //At least one is found
if(optimize_multikey){ if(optimize_multikey){
to_return.second = ++(priv_last_in_group)(it); to_return.second = ++(priv_last_in_group)(it);
internal_cnt += boost::intrusive::iterator_distance(++it, to_return.second); internal_cnt += boost::intrusive::iterator_udistance(++it, to_return.second);
} }
else{ else{
siterator const bend = b.end(); siterator const bend = b.end();
@ -3468,7 +3471,7 @@ class hashtable_impl
to_return.second = it; to_return.second = it;
} }
} }
cnt = internal_cnt; cnt = size_type(internal_cnt);
return to_return; return to_return;
} }
@ -3486,15 +3489,14 @@ class hashtable_impl
(this->priv_local_equal_range(key, hash_func, equal_func, n_bucket, cnt)); (this->priv_local_equal_range(key, hash_func, equal_func, n_bucket, cnt));
//If not, find the next element as ".second" if ".second" local iterator //If not, find the next element as ".second" if ".second" local iterator
//is not pointing to an element. //is not pointing to an element.
bucket_ptr const bp = this->priv_bucket_pointer();
if(to_return.first != to_return.second && if(to_return.first != to_return.second &&
to_return.second == bp[n_bucket].end()){ to_return.second == this->priv_bucket(n_bucket).end()){
to_return.second = this->priv_invalid_local_it(); to_return.second = this->priv_invalid_local_it();
++n_bucket; ++n_bucket;
for( const size_type max_bucket = this->bucket_count() for( const size_type max_bucket = this->bucket_count()
; n_bucket != max_bucket ; n_bucket != max_bucket
; ++n_bucket){ ; ++n_bucket){
bucket_type &b = bp[n_bucket]; bucket_type &b = this->priv_bucket(n_bucket);
if(!b.empty()){ if(!b.empty()){
to_return.second = b.begin(); to_return.second = b.begin();
break; break;

16
include/boost/intrusive/pointer_traits.hpp
View File

@ -46,6 +46,7 @@ BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_call
BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(element_type) BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(element_type)
BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type) BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(size_type)
BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference) BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference)
BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_traits_ptr) BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_traits_ptr)
@ -103,7 +104,13 @@ struct pointer_traits
(boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t) difference_type; (boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t) difference_type;
typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
(boost::intrusive::detail::, Ptr, reference, typename boost::intrusive::detail::unvoid_ref<element_type>::type) reference; ( boost::intrusive::detail::, Ptr, size_type
, typename boost::move_detail::
make_unsigned<difference_type>::type) size_type;
typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
( boost::intrusive::detail::, Ptr, reference
, typename boost::intrusive::detail::unvoid_ref<element_type>::type) reference;
// //
template <class U> struct rebind_pointer template <class U> struct rebind_pointer
{ {
@ -265,9 +272,10 @@ struct pointer_traits<Ptr&> : pointer_traits<Ptr> { };
template <typename T> template <typename T>
struct pointer_traits<T*> struct pointer_traits<T*>
{ {
typedef T element_type; typedef T element_type;
typedef T* pointer; typedef T* pointer;
typedef std::ptrdiff_t difference_type; typedef std::ptrdiff_t difference_type;
typedef std::size_t size_type;
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
typedef T & reference; typedef T & reference;

154
test/generic_assoc_test.hpp
View File

@ -16,10 +16,10 @@
#include "common_functors.hpp" #include "common_functors.hpp"
#include <boost/intrusive/options.hpp> #include <boost/intrusive/options.hpp>
#include <boost/intrusive/detail/mpl.hpp> #include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/detail/iterator.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include "test_macros.hpp" #include "test_macros.hpp"
#include "test_container.hpp" #include "test_container.hpp"
#include <boost/next_prior.hpp>
namespace boost{ namespace boost{
namespace intrusive{ namespace intrusive{
@ -90,7 +90,7 @@ void test_generic_assoc<ContainerDefiner>::test_insert_erase_burst()
const std::size_t MaxValues = 200; const std::size_t MaxValues = 200;
value_cont_type values(MaxValues); value_cont_type values(MaxValues);
for(std::size_t i = 0; i != MaxValues; ++i){ for(std::size_t i = 0; i != MaxValues; ++i){
(&values[i])->value_ = i; (&values[i])->value_ = (int)i;
} }
typedef typename ContainerDefiner::template container typedef typename ContainerDefiner::template container
@ -98,7 +98,7 @@ void test_generic_assoc<ContainerDefiner>::test_insert_erase_burst()
typedef typename assoc_type::iterator iterator; typedef typename assoc_type::iterator iterator;
{ //Ordered insertion + erasure { //Ordered insertion + erasure
assoc_type testset (values.begin(), values.begin() + values.size()); assoc_type testset (values.begin(), values.end());
TEST_INTRUSIVE_SEQUENCE_EXPECTED(testset, testset.begin()); TEST_INTRUSIVE_SEQUENCE_EXPECTED(testset, testset.begin());
testset.check(); testset.check();
iterator it(testset.begin()), itend(testset.end()); iterator it(testset.begin()), itend(testset.end());
@ -150,7 +150,7 @@ void test_generic_assoc<ContainerDefiner>::test_perfect_binary_tree_of_height_2
const std::size_t MaxValues = 7; const std::size_t MaxValues = 7;
BOOST_TEST(values.size() == MaxValues); BOOST_TEST(values.size() == MaxValues);
for(std::size_t i = 0; i != MaxValues; ++i){ for(std::size_t i = 0; i != MaxValues; ++i){
(&values[i])->value_ = i; (&values[i])->value_ = (int)i;
} }
typedef typename Assoc::iterator iterator; typedef typename Assoc::iterator iterator;
@ -194,26 +194,26 @@ void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
, value_traits_t::to_node_ptr(values[4]) , value_traits_t::to_node_ptr(values[4])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[4]) ( value_traits_t::to_node_ptr(values[4])
, value_traits_t::to_node_ptr(values[0]) , value_traits_t::to_node_ptr(values[0])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check(); testset.check();
} }
@ -228,26 +228,26 @@ void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
, value_traits_t::to_node_ptr(values[2]) , value_traits_t::to_node_ptr(values[2])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[0]) ( value_traits_t::to_node_ptr(values[0])
, value_traits_t::to_node_ptr(values[2]) , value_traits_t::to_node_ptr(values[2])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check(); testset.check();
} }
@ -262,26 +262,26 @@ void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
, value_traits_t::to_node_ptr(values[5]) , value_traits_t::to_node_ptr(values[5])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[1]) ( value_traits_t::to_node_ptr(values[1])
, value_traits_t::to_node_ptr(values[5]) , value_traits_t::to_node_ptr(values[5])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check(); testset.check();
} }
@ -296,26 +296,26 @@ void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
, value_traits_t::to_node_ptr(values[1]) , value_traits_t::to_node_ptr(values[1])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[0]) ( value_traits_t::to_node_ptr(values[0])
, value_traits_t::to_node_ptr(values[1]) , value_traits_t::to_node_ptr(values[1])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check(); testset.check();
} }
@ -330,26 +330,26 @@ void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
, value_traits_t::to_node_ptr(values[2]) , value_traits_t::to_node_ptr(values[2])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[1]) ( value_traits_t::to_node_ptr(values[1])
, value_traits_t::to_node_ptr(values[2]) , value_traits_t::to_node_ptr(values[2])
); );
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) ); BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check(); testset.check();
} }
@ -387,7 +387,7 @@ void test_generic_assoc<ContainerDefiner>::test_root(value_cont_type& values)
BOOST_TEST( testset1.croot() == ctestset1.cend()); BOOST_TEST( testset1.croot() == ctestset1.cend());
testset1.insert(values.begin(), values.begin() + values.size()); testset1.insert(values.begin(), values.end());
iterator i = testset1.root(); iterator i = testset1.root();
iterator i2(i); iterator i2(i);
@ -411,7 +411,7 @@ void test_generic_assoc<ContainerDefiner>::test_clone(value_cont_type& values)
typedef typename assoc_type::value_type value_type; typedef typename assoc_type::value_type value_type;
typedef typename assoc_type::size_type size_type; typedef typename assoc_type::size_type size_type;
assoc_type testset1 (values.begin(), values.begin() + values.size()); assoc_type testset1 (values.begin(), values.end());
assoc_type testset2; assoc_type testset2;
@ -436,7 +436,7 @@ void test_generic_assoc<ContainerDefiner>
{ {
typedef typename ContainerDefiner::template container typedef typename ContainerDefiner::template container
<>::type assoc_type; <>::type assoc_type;
assoc_type testset (values.begin(), values.begin() + values.size()); assoc_type testset (values.begin(), values.end());
BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.end())); BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.end()));
BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.cend())); BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.cend()));
} }

11
test/generic_multiset_test.hpp
View File

@ -10,8 +10,9 @@
// See http://www.boost.org/libs/intrusive for documentation. // See http://www.boost.org/libs/intrusive for documentation.
// //
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#include <boost/container/vector.hpp>
#include <boost/intrusive/detail/config_begin.hpp> #include <boost/intrusive/detail/config_begin.hpp>
#include <boost/container/vector.hpp>
#include "common_functors.hpp" #include "common_functors.hpp"
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/intrusive/options.hpp> #include <boost/intrusive/options.hpp>
@ -44,7 +45,7 @@ void test_generic_multiset<ContainerDefiner>::test_all ()
{ {
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
value_cont_type values (6); value_cont_type values (6);
for (int i = 0; i < 6; ++i) for (std::size_t i = 0u; i < 6u; ++i)
(&values[i])->value_ = random_init[i]; (&values[i])->value_ = random_init[i];
typedef typename ContainerDefiner::template container typedef typename ContainerDefiner::template container
<>::type multiset_type; <>::type multiset_type;
@ -75,13 +76,13 @@ template<class ContainerDefiner>
void test_generic_multiset<ContainerDefiner>::test_impl() void test_generic_multiset<ContainerDefiner>::test_impl()
{ {
value_cont_type values (5); value_cont_type values (5);
for (int i = 0; i < 5; ++i) for (std::size_t i = 0u; i < 5u; ++i)
(&values[i])->value_ = i; (&values[i])->value_ = (int)i;
typedef typename ContainerDefiner::template container typedef typename ContainerDefiner::template container
<>::type multiset_type; <>::type multiset_type;
multiset_type testset; multiset_type testset;
for (int i = 0; i < 5; ++i) for (std::size_t i = 0; i < 5u; ++i)
testset.insert (values[i]); testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0])); testset.erase (testset.iterator_to (values[0]));

16
test/generic_set_test.hpp
View File

@ -52,7 +52,7 @@ void test_generic_set<ContainerDefiner>::test_all()
{ {
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
value_cont_type values(6); value_cont_type values(6);
for (int i = 0; i < 6; ++i) for (std::size_t i = 0; i < 6u; ++i)
(&values[i])->value_ = random_init[i]; (&values[i])->value_ = random_init[i];
{ {
@ -80,8 +80,8 @@ void test_generic_set<ContainerDefiner>::test_all()
} }
{ {
value_cont_type values(6); value_cont_type values(6);
for (int i = 0; i < 6; ++i) for (std::size_t i = 0; i < 6u; ++i)
(&values[i])->value_ = i+1; (&values[i])->value_ = (int)i+1;
set_type testset(values.begin(), values.end()); set_type testset(values.begin(), values.end());
test::test_iterator_bidirectional(testset); test::test_iterator_bidirectional(testset);
} }
@ -92,13 +92,13 @@ template<class ContainerDefiner>
void test_generic_set<ContainerDefiner>::test_impl() void test_generic_set<ContainerDefiner>::test_impl()
{ {
value_cont_type values (5); value_cont_type values (5);
for (int i = 0; i < 5; ++i) for (std::size_t i = 0; i < 5u; ++i)
(&values[i])->value_ = i; (&values[i])->value_ = (int)i;
typedef typename ContainerDefiner::template container typedef typename ContainerDefiner::template container
<>::type set_type; <>::type set_type;
set_type testset; set_type testset;
for (int i = 0; i < 5; ++i) for (std::size_t i = 0; i < 5u; ++i)
testset.insert (values[i]); testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0])); testset.erase (testset.iterator_to (values[0]));
@ -202,7 +202,7 @@ void test_generic_set<ContainerDefiner>::test_insert_advanced
typedef priority_compare<> prio_comp_t; typedef priority_compare<> prio_comp_t;
{ {
set_type testset; set_type testset;
testset.insert(values.begin(), values.begin() + values.size()); testset.insert(values.begin(), values.end());
testset.check(); testset.check();
value_type v(1); value_type v(1);
typename set_type::insert_commit_data data; typename set_type::insert_commit_data data;
@ -224,7 +224,7 @@ void test_generic_set<ContainerDefiner>::test_insert_advanced
typedef typename set_type::value_type value_type; typedef typename set_type::value_type value_type;
{ {
set_type testset; set_type testset;
testset.insert(values.begin(), values.begin() + values.size()); testset.insert(values.begin(), values.end());
testset.check(); testset.check();
value_type v(1); value_type v(1);
typename set_type::insert_commit_data data; typename set_type::insert_commit_data data;

5
test/iterator_test.hpp
View File

@ -258,10 +258,11 @@ template<class C, class I>
void test_iterator_random_functions(C const &c, I const b, I const e) void test_iterator_random_functions(C const &c, I const b, I const e)
{ {
typedef typename C::size_type size_type; typedef typename C::size_type size_type;
typedef typename C::difference_type difference_type;
{ {
I it = b; I it = b;
for(size_type i = 0, m = c.size(); i != m; ++i, ++it){ for(difference_type i = 0, m = difference_type(c.size()); i != m; ++i, ++it){
BOOST_TEST(i == size_type(it - b)); BOOST_TEST(i == it - b);
BOOST_TEST(b[i] == *it); BOOST_TEST(b[i] == *it);
BOOST_TEST(&b[i] == &*it); BOOST_TEST(&b[i] == &*it);
BOOST_TEST((b + i) == it); BOOST_TEST((b + i) == it);

36
test/list_test.cpp
View File

@ -239,28 +239,28 @@ void test_list< ListType, ValueContainer >
::test_shift(ValueContainer& values) ::test_shift(ValueContainer& values)
{ {
list_type testlist; list_type testlist;
const int num_values = (int)values.size(); const std::size_t num_values = values.size();
std::vector<int> expected_values(num_values); std::vector<int> expected_values(num_values);
for(int s = 1; s <= num_values; ++s){ for(std::size_t s = 1u; s <= num_values; ++s){
expected_values.resize(s); expected_values.resize(s);
//Shift forward all possible positions 3 times //Shift forward all possible positions 3 times
for(int i = 0; i < s*3; ++i){ for(std::size_t i = 0u; i < s*3u; ++i){
testlist.insert(testlist.begin(), values.begin(), values.begin() + s); testlist.insert(testlist.begin(), values.begin(), values.begin() + std::ptrdiff_t(s));
testlist.shift_forward(i); testlist.shift_forward(i);
for(int j = 0; j < s; ++j){ for(std::size_t j = 0u; j < s; ++j){
expected_values[(j + s - i%s) % s] = (j + 1); expected_values[(j + s - i%s) % s] = int(j + 1u);
} }
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin()); TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin());
testlist.clear(); testlist.clear();
} }
//Shift backwards all possible positions //Shift backwards all possible positions
for(int i = 0; i < s*3; ++i){ for(std::size_t i = 0u; i < s*3u; ++i){
testlist.insert(testlist.begin(), values.begin(), values.begin() + s); testlist.insert(testlist.begin(), values.begin(), values.begin() + std::ptrdiff_t(s));
testlist.shift_backwards(i); testlist.shift_backwards(i);
for(int j = 0; j < s; ++j){ for(std::size_t j = 0u; j < s; ++j){
expected_values[(j + i) % s] = (j + 1); expected_values[(j + i) % s] = int(j + 1);
} }
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin()); TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin());
testlist.clear(); testlist.clear();
@ -384,7 +384,7 @@ template < class ListType, typename ValueContainer >
void test_list< ListType, ValueContainer > void test_list< ListType, ValueContainer >
::test_container_from_end(ValueContainer& values, detail::true_type) ::test_container_from_end(ValueContainer& values, detail::true_type)
{ {
list_type testlist1 (values.begin(), values.begin() + values.size()); list_type testlist1 (values.begin(), values.begin() + std::ptrdiff_t(values.size()));
BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.end())); BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.end()));
BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.cend())); BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.cend()));
} }
@ -393,7 +393,7 @@ template < class ListType, typename ValueContainer >
void test_list< ListType, ValueContainer > void test_list< ListType, ValueContainer >
::test_clone(ValueContainer& values) ::test_clone(ValueContainer& values)
{ {
list_type testlist1 (values.begin(), values.begin() + values.size()); list_type testlist1 (values.begin(), values.begin() + std::ptrdiff_t(values.size()));
list_type testlist2; list_type testlist2;
testlist2.clone_from(testlist1, test::new_cloner<value_type>(), test::delete_disposer<value_type>()); testlist2.clone_from(testlist1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
@ -434,8 +434,8 @@ class test_main_template
{ {
typedef testvalue< hooks<VoidPointer> > value_type; typedef testvalue< hooks<VoidPointer> > value_type;
std::vector<value_type> data (5); std::vector<value_type> data (5);
for (int i = 0; i < 5; ++i) for (std::size_t i = 0u; i < 5u; ++i)
data[i].value_ = i + 1; data[i].value_ = (int)i + 1;
make_and_test_list < typename detail::get_base_value_traits < make_and_test_list < typename detail::get_base_value_traits <
value_type, value_type,
@ -475,8 +475,8 @@ class test_main_template< VoidPointer, false, Default_Holder >
{ {
typedef testvalue< hooks<VoidPointer> > value_type; typedef testvalue< hooks<VoidPointer> > value_type;
std::vector<value_type> data (5); std::vector<value_type> data (5);
for (int i = 0; i < 5; ++i) for (std::size_t i = 0; i < 5u; ++i)
data[i].value_ = i + 1; data[i].value_ = (int)i + 1;
make_and_test_list < typename detail::get_base_value_traits < make_and_test_list < typename detail::get_base_value_traits <
value_type, value_type,
@ -514,10 +514,10 @@ struct test_main_template_bptr
{ {
bounded_reference_cont< value_type > ref_cont; bounded_reference_cont< value_type > ref_cont;
for (int i = 0; i < 5; ++i) for (std::size_t i = 0; i < 5u; ++i)
{ {
node_ptr tmp = allocator.allocate(1); node_ptr tmp = allocator.allocate(1);
new (tmp.raw()) value_type(i + 1); new (tmp.raw()) value_type((int)i + 1);
ref_cont.push_back(*tmp); ref_cont.push_back(*tmp);
} }

36
test/slist_test.cpp
View File

@ -291,17 +291,17 @@ void test_slist< ListType, ValueContainer >
::test_shift(ValueContainer& values) ::test_shift(ValueContainer& values)
{ {
list_type testlist; list_type testlist;
const int num_values = (int)values.size(); const std::size_t num_values = values.size();
std::vector<int> expected_values(num_values); std::vector<int> expected_values(num_values);
//Shift forward all possible positions 3 times //Shift forward all possible positions 3 times
for(int s = 1; s <= num_values; ++s){ for(std::size_t s = 1; s <= num_values; ++s){
expected_values.resize(s); expected_values.resize(s);
for(int i = 0; i < s*3; ++i){ for(std::size_t i = 0; i < s*3u; ++i){
testlist.insert_after(testlist.before_begin(), values.begin(), values.begin() + s); testlist.insert_after(testlist.before_begin(), values.begin(), values.begin() + std::ptrdiff_t(s));
testlist.shift_forward(i); testlist.shift_forward(i);
for(int j = 0; j < s; ++j){ for(std::size_t j = 0; j < s; ++j){
expected_values[(j + s - i%s) % s] = (j + 1); expected_values[(j + s - i%s) % s] = int(j + 1);
} }
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin()) TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin())
@ -309,11 +309,11 @@ void test_slist< ListType, ValueContainer >
} }
//Shift backwards all possible positions //Shift backwards all possible positions
for(int i = 0; i < s*3; ++i){ for(std::size_t i = 0; i < s*3u; ++i){
testlist.insert_after(testlist.before_begin(), values.begin(), values.begin() + s); testlist.insert_after(testlist.before_begin(), values.begin(), values.begin() + std::ptrdiff_t(s));
testlist.shift_backwards(i); testlist.shift_backwards(i);
for(int j = 0; j < s; ++j){ for(std::size_t j = 0; j < s; ++j){
expected_values[(j + i) % s] = (j + 1); expected_values[(j + i) % s] = int(j + 1);
} }
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin()) TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin())
@ -463,7 +463,7 @@ template < typename ListType, typename ValueContainer >
void test_slist< ListType, ValueContainer > void test_slist< ListType, ValueContainer >
::test_clone(ValueContainer& values) ::test_clone(ValueContainer& values)
{ {
list_type testlist1 (values.begin(), values.begin() + values.size()); list_type testlist1 (values.begin(), values.begin() + std::ptrdiff_t(values.size()));
list_type testlist2; list_type testlist2;
testlist2.clone_from(testlist1, test::new_cloner<value_type>(), test::delete_disposer<value_type>()); testlist2.clone_from(testlist1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
@ -476,7 +476,7 @@ template < typename ListType, typename ValueContainer >
void test_slist< ListType, ValueContainer > void test_slist< ListType, ValueContainer >
::test_container_from_end(ValueContainer& values, detail::true_type) ::test_container_from_end(ValueContainer& values, detail::true_type)
{ {
list_type testlist1 (values.begin(), values.begin() + values.size()); list_type testlist1 (values.begin(), values.begin() + std::ptrdiff_t(values.size()));
BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.end())); BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.end()));
BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.cend())); BOOST_TEST (testlist1 == list_type::container_from_end_iterator(testlist1.cend()));
} }
@ -516,8 +516,8 @@ class test_main_template
{ {
typedef testvalue< hooks<VoidPointer> > value_type; typedef testvalue< hooks<VoidPointer> > value_type;
std::vector< value_type > data (5); std::vector< value_type > data (5);
for (int i = 0; i < 5; ++i) for (std::size_t i = 0; i < 5u; ++i)
data[i].value_ = i + 1; data[i].value_ = (int)i + 1;
make_and_test_slist < typename detail::get_base_value_traits make_and_test_slist < typename detail::get_base_value_traits
< value_type < value_type
@ -590,8 +590,8 @@ class test_main_template<VoidPointer, false, Default_Holder>
{ {
typedef testvalue< hooks<VoidPointer> > value_type; typedef testvalue< hooks<VoidPointer> > value_type;
std::vector< value_type > data (5); std::vector< value_type > data (5);
for (int i = 0; i < 5; ++i) for (std::size_t i = 0; i < 5u; ++i)
data[i].value_ = i + 1; data[i].value_ = (int)i + 1;
make_and_test_slist < typename detail::get_base_value_traits make_and_test_slist < typename detail::get_base_value_traits
< value_type < value_type
@ -659,10 +659,10 @@ struct test_main_template_bptr
{ {
bounded_reference_cont< value_type > ref_cont; bounded_reference_cont< value_type > ref_cont;
for (int i = 0; i < 5; ++i) for (std::size_t i = 0; i < 5u; ++i)
{ {
node_ptr tmp = allocator.allocate(1); node_ptr tmp = allocator.allocate(1);
new (tmp.raw()) value_type(i + 1); new (tmp.raw()) value_type((int)i + 1);
ref_cont.push_back(*tmp); ref_cont.push_back(*tmp);
} }

6
test/test_container.hpp
View File

@ -493,10 +493,10 @@ void test_unordered_associative_container_invariants(Container & c, Data & d)
} }
} }
size_type blen = c.bucket_count(); std::size_t blen = c.bucket_count();
size_type total_objects = 0; std::size_t total_objects = 0;
for(size_type i = 0; i < blen; ++i){ for(size_type i = 0; i < blen; ++i){
total_objects += c.bucket_size(i); total_objects += std::size_t(c.bucket_size(i));
} }
BOOST_TEST( total_objects == c.size() ); BOOST_TEST( total_objects == c.size() );
} }

2
test/test_macros.hpp
View File

@ -25,7 +25,7 @@ struct is_multikey_true
{ {
typedef char yes_type; typedef char yes_type;
template<bool IsMultikey> template<bool IsMultikey>
struct two { yes_type _[1+IsMultikey]; }; struct two { yes_type _[1u+unsigned(IsMultikey)]; };
template <class U> static yes_type test(...); template <class U> static yes_type test(...);
template <class U> static two<U::is_multikey>test(int); template <class U> static two<U::is_multikey>test(int);
static const bool value = sizeof(test<T>(0)) != sizeof(yes_type); static const bool value = sizeof(test<T>(0)) != sizeof(yes_type);

6
test/unordered_multiset_test.cpp
View File

@ -75,7 +75,7 @@ class test_main_template<VoidPointer, ConstantTimeSize, DefaultHolder, Map, Base
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
typedef typename ValueContainer< value_type >::type value_cont_type; typedef typename ValueContainer< value_type >::type value_cont_type;
value_cont_type data (6); value_cont_type data (6);
for (int i = 0; i < 6; ++i) for (std::size_t i = 0u; i < 6u; ++i)
data[i].value_ = random_init[i]; data[i].value_ = random_init[i];
typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t; typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t;
@ -102,7 +102,7 @@ class test_main_template<VoidPointer, ConstantTimeSize, DefaultHolder, Map, Memb
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
typedef typename ValueContainer< value_type >::type value_cont_type; typedef typename ValueContainer< value_type >::type value_cont_type;
value_cont_type data (6); value_cont_type data (6);
for (int i = 0; i < 6; ++i) for (std::size_t i = 0u; i < 6u; ++i)
data[i].value_ = random_init[i]; data[i].value_ = random_init[i];
typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t; typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t;
@ -130,7 +130,7 @@ class test_main_template<VoidPointer, ConstantTimeSize, DefaultHolder, Map, NonM
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
typedef typename ValueContainer< value_type >::type value_cont_type; typedef typename ValueContainer< value_type >::type value_cont_type;
value_cont_type data (6); value_cont_type data (6);
for (int i = 0; i < 6; ++i) for (std::size_t i = 0; i < 6u; ++i)
data[i].value_ = random_init[i]; data[i].value_ = random_init[i];
typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t; typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t;

6
test/unordered_set_test.cpp
View File

@ -74,7 +74,7 @@ class test_main_template<VoidPointer, ConstantTimeSize, DefaultHolder, Map, Base
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
typedef typename ValueContainer< value_type >::type value_cont_type; typedef typename ValueContainer< value_type >::type value_cont_type;
value_cont_type data (6); value_cont_type data (6);
for (int i = 0; i < 6; ++i) for (std::size_t i = 0; i < 6u; ++i)
data[i].value_ = random_init[i]; data[i].value_ = random_init[i];
typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t; typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t;
@ -101,7 +101,7 @@ class test_main_template<VoidPointer, ConstantTimeSize, DefaultHolder, Map, Memb
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
typedef typename ValueContainer< value_type >::type value_cont_type; typedef typename ValueContainer< value_type >::type value_cont_type;
value_cont_type data (6); value_cont_type data (6);
for (int i = 0; i < 6; ++i) for (std::size_t i = 0; i < 6u; ++i)
data[i].value_ = random_init[i]; data[i].value_ = random_init[i];
typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t; typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t;
@ -129,7 +129,7 @@ class test_main_template<VoidPointer, ConstantTimeSize, DefaultHolder, Map, NonM
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
typedef typename ValueContainer< value_type >::type value_cont_type; typedef typename ValueContainer< value_type >::type value_cont_type;
value_cont_type data (6); value_cont_type data (6);
for (int i = 0; i < 6; ++i) for (std::size_t i = 0; i < 6u; ++i)
data[i].value_ = random_init[i]; data[i].value_ = random_init[i];
typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t; typedef testvalue_traits< unordered_hooks<VoidPointer> > testval_traits_t;

34
test/unordered_test.hpp
View File

@ -72,8 +72,8 @@ void test_unordered<ContainerDefiner>::test_all (value_cont_type& values)
} }
{ {
value_cont_type vals(BucketSize); value_cont_type vals(BucketSize);
for (int i = 0; i < (int)BucketSize; ++i) for (std::size_t i = 0; i < BucketSize; ++i)
(&vals[i])->value_ = i; (&vals[i])->value_ = (int)i;
typename unordered_type::bucket_type buckets [BucketSize]; typename unordered_type::bucket_type buckets [BucketSize];
unordered_type testset(bucket_traits( unordered_type testset(bucket_traits(
pointer_traits<bucket_ptr>::pointer_to(buckets[0]), BucketSize)); pointer_traits<bucket_ptr>::pointer_to(buckets[0]), BucketSize));
@ -99,14 +99,14 @@ void test_unordered<ContainerDefiner>::test_impl()
typedef typename unordered_type::bucket_ptr bucket_ptr; typedef typename unordered_type::bucket_ptr bucket_ptr;
value_cont_type values (5); value_cont_type values (5);
for (int i = 0; i < 5; ++i) for (std::size_t i = 0u; i < 5u; ++i)
values[i].value_ = i; values[i].value_ = (int)i;
typename unordered_type::bucket_type buckets [BucketSize]; typename unordered_type::bucket_type buckets [BucketSize];
unordered_type testset(bucket_traits( unordered_type testset(bucket_traits(
pointer_traits<bucket_ptr>::pointer_to(buckets[0]), BucketSize)); pointer_traits<bucket_ptr>::pointer_to(buckets[0]), BucketSize));
for (int i = 0; i < 5; ++i) for (std::size_t i = 0u; i < 5u; ++i)
testset.insert (values[i]); testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0])); testset.erase (testset.iterator_to (values[0]));
@ -309,11 +309,11 @@ void test_unordered<ContainerDefiner>::test_insert(value_cont_type& values, deta
{ {
//Now erase just one per loop //Now erase just one per loop
const int random_init[] = { 3, 2, 4, 1, 5, 2, 2 }; const int random_init[] = { 3, 2, 4, 1, 5, 2, 2 };
const unsigned int random_size = sizeof(random_init)/sizeof(random_init[0]); const std::size_t random_size = sizeof(random_init)/sizeof(random_init[0]);
typename unordered_type::bucket_type single_bucket[1]; typename unordered_type::bucket_type single_bucket[1];
for(unsigned int i = 0, max = random_size; i != max; ++i){ for(std::size_t i = 0u, max = random_size; i != max; ++i){
value_cont_type data (random_size); value_cont_type data (random_size);
for (unsigned int j = 0; j < random_size; ++j) for (std::size_t j = 0; j < random_size; ++j)
data[j].value_ = random_init[j]; data[j].value_ = random_init[j];
unordered_type testset_new(bucket_traits( unordered_type testset_new(bucket_traits(
pointer_traits<bucket_ptr>::pointer_to(single_bucket[0]), 1)); pointer_traits<bucket_ptr>::pointer_to(single_bucket[0]), 1));
@ -324,22 +324,22 @@ void test_unordered<ContainerDefiner>::test_insert(value_cont_type& values, deta
} }
} }
{ {
const unsigned int LoadFactor = 3; const std::size_t LoadFactor = 3;
const unsigned int NumIterations = BucketSize*LoadFactor; const std::size_t NumIterations = BucketSize*LoadFactor;
value_cont_type random_init(NumIterations);//Preserve memory value_cont_type random_init(NumIterations);//Preserve memory
value_cont_type set_tester; value_cont_type set_tester;
set_tester.reserve(NumIterations); set_tester.reserve(NumIterations);
//Initialize values //Initialize values
for (unsigned int i = 0; i < NumIterations; ++i){ for (std::size_t i = 0u; i < NumIterations; ++i){
random_init[i].value_ = i*2;//(i/LoadFactor)*LoadFactor; random_init[i].value_ = (int)i*2;//(i/LoadFactor)*LoadFactor;
} }
typename unordered_type::bucket_type buckets [BucketSize]; typename unordered_type::bucket_type buckets [BucketSize];
bucket_traits btraits(pointer_traits<bucket_ptr>::pointer_to(buckets[0]), BucketSize); bucket_traits btraits(pointer_traits<bucket_ptr>::pointer_to(buckets[0]), BucketSize);
for(unsigned int initial_pos = 0; initial_pos != (NumIterations+1); ++initial_pos){ for(std::size_t initial_pos = 0; initial_pos != (NumIterations+1u); ++initial_pos){
for(unsigned int final_pos = initial_pos; final_pos != (NumIterations+1); ++final_pos){ for(std::size_t final_pos = initial_pos; final_pos != (NumIterations+1); ++final_pos){
//Create intrusive container inserting values //Create intrusive container inserting values
unordered_type testset unordered_type testset
@ -351,16 +351,16 @@ void test_unordered<ContainerDefiner>::test_insert(value_cont_type& values, deta
//Obtain the iterator range to erase //Obtain the iterator range to erase
iterator it_beg_pos = testset.begin(); iterator it_beg_pos = testset.begin();
for(unsigned int it_beg_pos_num = 0; it_beg_pos_num != initial_pos; ++it_beg_pos_num){ for(std::size_t it_beg_pos_num = 0; it_beg_pos_num != initial_pos; ++it_beg_pos_num){
++it_beg_pos; ++it_beg_pos;
} }
iterator it_end_pos(it_beg_pos); iterator it_end_pos(it_beg_pos);
for(unsigned int it_end_pos_num = 0; it_end_pos_num != (final_pos - initial_pos); ++it_end_pos_num){ for(std::size_t it_end_pos_num = 0; it_end_pos_num != (final_pos - initial_pos); ++it_end_pos_num){
++it_end_pos; ++it_end_pos;
} }
//Erase the same values in both the intrusive and original vector //Erase the same values in both the intrusive and original vector
std::size_t erased_cnt = boost::intrusive::iterator_distance(it_beg_pos, it_end_pos); std::size_t erased_cnt = boost::intrusive::iterator_udistance(it_beg_pos, it_end_pos);
//Erase values from the intrusive container //Erase values from the intrusive container
testset.erase(it_beg_pos, it_end_pos); testset.erase(it_beg_pos, it_end_pos);