boost_mirror/intrusive
1
0
Fork 0
mirror of https://github.com/boostorg/intrusive.git synced 2025-05-09 23:03:56 +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()
{
const int MaxElem = 100;
const std::size_t MaxElem = 100;
std::vector<my_class> nodes(MaxElem);
//Fill all the nodes and insert them in the 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());

8
example/doc_iterator_from_value.cpp
View File

@ -57,7 +57,7 @@ typedef boost::intrusive::unordered_set
int main()
{
//Create MaxElem objects
const int MaxElem = 100;
const std::size_t MaxElem = 100;
std::vector<intrusive_data> nodes(MaxElem);
//Declare the intrusive containers
@ -67,7 +67,7 @@ int main()
(unordered_set_t::bucket_traits(buckets, MaxElem));
//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
list.insert(list.end(), nodes.begin(), nodes.end());
@ -75,7 +75,7 @@ int main()
//Now check the iterator_to function
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 ||
list_t::s_iterator_to(nodes[i]) != list_it)
return 1;
@ -83,7 +83,7 @@ int main()
//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)
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]);
if(unordered_set.iterator_to(nodes[i]) != unordered_set_it)
return 1;

6
example/doc_offset_ptr.cpp
View File

@ -68,8 +68,8 @@ int main()
{
//Now create an intrusive list in shared memory:
//nodes and the container itself must be created in shared memory
const int MaxElem = 100;
const int ShmSize = 50000;
const std::size_t MaxElem = 100;
const std::size_t ShmSize = 50000;
const char *ShmName = get_shared_memory_name();
{
//Erase all old shared memory
@ -88,7 +88,7 @@ int main()
pshm_vect->resize(MaxElem);
//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
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
//all elements, which is more efficient than normal insertion
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
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
//so let's push front all elements
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
multiset<MyClass, compare< std::greater<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 push the first and the last and insert the rest
//before the last position using "insert_before"
@ -62,7 +62,7 @@ int main()
mset.insert_before(mset.begin(), values[0]);
multiset<MyClass>::const_iterator pos =
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
multiset<MyClass>::const_iterator next(mset.cbegin()), it(next++);

2
example/doc_treap_algorithms.cpp
View File

@ -15,7 +15,7 @@
struct my_node
{
my_node(int i = 0, unsigned int priority = 0)
my_node(int i = 0, int priority = 0)
: prio_(priority), int_(i)
{}
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
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;
MemberMultiset membermultiset;

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

@ -142,25 +142,25 @@ struct iterator_disable_if_tag_difference_type
// advance
////////////////////
template<class InputIt, class Distance>
template<class InputIt>
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--)
++it;
}
template<class InputIt, class Distance>
template<class InputIt>
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--)
++it;
}
template<class InputIt, class Distance>
template<class InputIt>
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)
++it;
@ -175,37 +175,37 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
it += n;
}
template<class InputIt, class Distance>
template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<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--)
++it;
}
template<class InputIt, class Distance>
template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<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--)
++it;
}
template<class InputIt, class Distance>
template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<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--)
++it;
}
template<class InputIt, class Distance>
template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<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)
++it;
@ -215,17 +215,24 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
class fake{};
template<class InputIt, class Distance>
template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
<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;
}
////////////////////
// distance
////////////////////
template<class It>
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
typename iterator_disable_if_tag_difference_type
<InputIt, std::random_access_iterator_tag>::type
@ -248,6 +255,39 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
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>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
{ 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 >
{
static ::boost::ulong_long_type call(::boost::ulong_long_type n)
{ return __builtin_clzll(n); }
{ return (::boost::ulong_long_type)__builtin_clzll(n); }
};
#endif
@ -101,14 +101,14 @@ namespace detail {
struct builtin_clz_dispatch<unsigned long>
{
static unsigned long call(unsigned long n)
{ return __builtin_clzl(n); }
{ return (unsigned long)__builtin_clzl(n); }
};
template<>
struct builtin_clz_dispatch<unsigned int>
{
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)

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

@ -155,7 +155,7 @@ template <class T>\
struct TRAITS_PREFIX##_bool\
{\
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 two_or_three<U::TYPEDEF_TO_FIND> test (int);\
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
#define BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
#ifndef BOOST_CONFIG_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>
#include <boost/move/detail/reverse_iterator.hpp>
namespace boost {
namespace intrusive {
template<class It>
class 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
};
using boost::movelib::reverse_iterator;
using boost::movelib::make_reverse_iterator;
} //namespace intrusive {
} //namespace boost {
#include <boost/intrusive/detail/config_end.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
{
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 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>
struct optimize_multikey_is_true
{
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 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
@ -735,18 +735,22 @@ struct bucket_plus_vtraits
BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_bucket_pointer() const BOOST_NOEXCEPT
{ return this->priv_bucket_traits().bucket_begin(); }
template<class SizeType>
SizeType priv_bucket_count() const BOOST_NOEXCEPT
std::size_t priv_bucket_count() const BOOST_NOEXCEPT
{
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 static_cast<SizeType>(bc);
return 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
{
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
@ -849,7 +853,7 @@ struct bucket_plus_vtraits
std::size_t num_erased(0);
siterator last_step_before_it;
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
(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){
@ -861,7 +865,7 @@ struct bucket_plus_vtraits
last_step_before_it = before_first_it;
}
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;
}
@ -917,23 +921,25 @@ struct bucket_plus_vtraits
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
( f->end().pointed_node()
, l->end().pointed_node()
( f.end().pointed_node()
, l.end().pointed_node()
, detail::dcast_bucket_ptr<node>(it.pointed_node()));
//Now get the bucket_impl from the iterator
const bucket_type &b = static_cast<const bucket_type&>
(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
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
{
bucket_ptr f(this->priv_bucket_pointer()), l(f + this->template priv_bucket_count<std::size_t>() - 1);
slist_node_ptr first_ptr(f->cend().pointed_node())
, last_ptr(l->cend().pointed_node());
const bucket_type &f = this->priv_bucket(0u);
const bucket_type &l = this->priv_bucket(this->priv_bucket_count() - 1u);
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:
//iterate until we reach it.
@ -946,7 +952,7 @@ struct bucket_plus_vtraits
(bucket_type::container_from_end_iterator(it));
//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
@ -1168,9 +1174,9 @@ struct bucket_hash_equal_t
siterator priv_begin() const
{
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){
bucket_type &b = this->bucket_hash_type::priv_bucket_pointer()[n];
bucket_type &b = this->bucket_hash_type::priv_bucket(n);
if(!b.empty()){
return b.begin();
}
@ -1233,7 +1239,7 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
{ cached_begin_ = p; }
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()
{ 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)
{
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_){
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
//to the last position if all
if(this->priv_get_cache_bucket_num() == first_bucket_num &&
this->bucket_hash_type::priv_bucket_pointer()[first_bucket_num].empty() ){
this->priv_set_cache(this->bucket_hash_type::priv_bucket_pointer() + last_bucket_num);
this->bucket_hash_type::priv_bucket(first_bucket_num).empty() ){
this->priv_set_cache(this->bucket_hash_type::priv_bucket_pointer() + std::ptrdiff_t(last_bucket_num));
this->priv_erasure_update_cache();
}
}
@ -1281,8 +1288,8 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
void priv_erasure_update_cache()
{
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();
for( const std::size_t num_buckets = this->bucket_hash_type::template priv_bucket_count<std::size_t>()
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::priv_bucket_count()
; current_n < num_buckets
; ++current_n, ++this->priv_get_cache()){
if(!this->priv_get_cache()->empty()){
@ -1441,11 +1448,10 @@ struct hashdata_internal
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->priv_get_cache()
, this->internal_type::template priv_bucket_count<size_type>()
- (this->priv_get_cache()
- this->internal_type::priv_bucket_pointer()));
, this->internal_type::priv_bucket_count() - cache_num);
}
void priv_clear_buckets_and_cache()
@ -1458,7 +1464,7 @@ struct hashdata_internal
{
this->internal_type::priv_clear_buckets
( 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();
}
@ -1525,16 +1531,16 @@ struct hashdata_internal
}
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
{ 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
{ return this->priv_bucket_pointer(); }
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
{ return this->cbegin(n); }
@ -1552,7 +1558,7 @@ struct hashdata_internal
const_local_iterator cbegin(size_type n) const BOOST_NOEXCEPT
{
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());
}
@ -1560,7 +1566,7 @@ struct hashdata_internal
using internal_type::cend;
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
{ return this->cend(n); }
@ -1568,7 +1574,7 @@ struct hashdata_internal
const_local_iterator cend(size_type n) const BOOST_NOEXCEPT
{
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());
}
@ -1819,7 +1825,7 @@ class hashtable_impl
//Check power of two bucket array if the option is activated
BOOST_INTRUSIVE_INVARIANT_ASSERT
(!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
@ -1852,7 +1858,7 @@ class hashtable_impl
//Check power of two bucket array if the option is activated
BOOST_INTRUSIVE_INVARIANT_ASSERT
(!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
if(unique)
this->insert_unique(b, e);
@ -2000,13 +2006,14 @@ class hashtable_impl
BOOST_IF_CONSTEXPR(constant_time_size)
return this->priv_size_traits().get_size();
else{
size_type len = 0;
size_type bucket_cnt = this->bucket_count();
std::size_t len = 0;
std::size_t bucket_cnt = this->bucket_count();
const bucket_type *b = boost::movelib::to_raw_pointer(this->priv_bucket_pointer());
for (size_type n = 0; n < bucket_cnt; ++n, ++b){
len += (size_type)b->size();
for (std::size_t n = 0; n < bucket_cnt; ++n, ++b){
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
{
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();
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));
@ -2360,7 +2367,7 @@ class hashtable_impl
//Get the bucket number and local iterator for both iterators
siterator const first_local_it(i.slist_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_erasure_update_cache_range(first_bucket_num, first_bucket_num);
}
@ -2385,17 +2392,16 @@ class hashtable_impl
siterator first_local_it(b.slist_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
= 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;
siterator last_local_it;
//For the end iterator, we will assign the end iterator
//of the last bucket
if(e == this->end()){
last_bucket_num = this->bucket_count() - 1;
last_local_it = buck_ptr[last_bucket_num].end();
last_bucket_num = size_type(this->bucket_count() - 1u);
last_local_it = this->priv_bucket(last_bucket_num).end();
}
else{
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
( before_first_local_it, first_bucket_num, last_local_it, last_bucket_num
, 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);
}
}
@ -2457,10 +2463,10 @@ class hashtable_impl
if(success){
if(optimize_multikey){
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{
bucket_type &b = this->priv_bucket_pointer()[bucket_num];
bucket_type &b = this->priv_bucket(bucket_num);
siterator const end_sit = b.end();
do{
++cnt;
@ -2470,7 +2476,7 @@ class hashtable_impl
(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));
}
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();
}
@ -2981,34 +2987,33 @@ class hashtable_impl
{
//This function is only available for containers with incremental hashing
BOOST_STATIC_ASSERT(( incremental && power_2_buckets ));
const size_type split_idx = this->priv_split_traits().get_size();
const size_type bucket_cnt = this->bucket_count();
const bucket_ptr buck_ptr = this->priv_bucket_pointer();
const std::size_t split_idx = this->priv_split_traits().get_size();
const std::size_t bucket_cnt = this->bucket_count();
bool ret = false;
if(grow){
//Test if the split variable can be changed
if((ret = split_idx < bucket_cnt)){
const size_type bucket_to_rehash = split_idx - bucket_cnt/2;
bucket_type &old_bucket = buck_ptr[bucket_to_rehash];
const std::size_t bucket_to_rehash = split_idx - bucket_cnt/2u;
bucket_type &old_bucket = this->priv_bucket(bucket_to_rehash);
this->priv_split_traits().increment();
//Anti-exception stuff: if an exception is thrown while
//moving elements from old_bucket to the target bucket, all moved
//elements are moved back to the original one.
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())
; i != end_sit; i = before_i, ++i){
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 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);
if(new_n == bucket_to_rehash){
before_i = last;
}
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);
}
}
@ -3016,10 +3021,10 @@ class hashtable_impl
this->priv_erasure_update_cache();
}
}
else if((ret = split_idx > bucket_cnt/2)){ //!grow
const size_type target_bucket_num = size_type(split_idx - 1u - bucket_cnt/2u);
bucket_type &target_bucket = buck_ptr[target_bucket_num];
bucket_type &source_bucket = buck_ptr[split_idx-1];
else if((ret = split_idx > bucket_cnt/2u)){ //!grow
const std::size_t target_bucket_num = split_idx - 1u - bucket_cnt/2u;
bucket_type &target_bucket = this->priv_bucket(target_bucket_num);
bucket_type &source_bucket = this->priv_bucket(split_idx-1u);
target_bucket.splice_after(target_bucket.cbefore_begin(), source_bucket);
this->priv_split_traits().decrement();
this->priv_insertion_update_cache(target_bucket_num);
@ -3068,8 +3073,8 @@ class hashtable_impl
this->priv_bucket_traits() = new_bucket_traits;
if(new_bucket_traits.bucket_begin() != old_buckets){
for(size_type n = ini_n; n < split_idx; ++n){
bucket_type &new_bucket = new_bucket_traits.bucket_begin()[n];
bucket_type &old_bucket = old_buckets[n];
bucket_type &new_bucket = new_bucket_traits.bucket_begin()[difference_type(n)];
bucket_type &old_bucket = old_buckets[difference_type(n)];
new_bucket.splice_after(new_bucket.cbefore_begin(), old_bucket);
}
//Put cache to safe position
@ -3198,7 +3203,7 @@ class hashtable_impl
//Iterate through nodes
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){
for( siterator before_i(old_bucket.before_begin()), i(old_bucket.begin()), end_sit(old_bucket.end())
; i != end_sit
@ -3231,7 +3236,7 @@ class hashtable_impl
before_i = last;
}
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);
}
}
@ -3241,7 +3246,7 @@ class hashtable_impl
<power_2_buckets, incremental>(n, new_bucket_count, new_bucket_count);
if(cache_begin && new_n < new_first_bucket_num)
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()
, old_bucket
, old_bucket.before_begin()
@ -3311,7 +3316,7 @@ class hashtable_impl
//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());;
//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());
//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
@ -3328,22 +3333,20 @@ class hashtable_impl
//First clone the first ones
const size_type src_bucket_count = src.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;
typedef node_cast_adaptor< detail::node_disposer<Disposer, value_traits, CircularSListAlgorithms>
, slist_node_ptr, node_ptr > NodeDisposer;
NodeDisposer node_disp(disposer, &this->priv_value_traits());
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
for( //"constructed" already initialized
; constructed < src_bucket_count
; ++constructed){
//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>());
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){
slist_node_ptr const n(b.pointed_node());
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
{
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();
siterator it = previt;
siterator const endit = b.end();
@ -3438,7 +3441,7 @@ class hashtable_impl
, size_type &found_bucket
, size_type &cnt) const
{
size_type internal_cnt = 0;
std::size_t internal_cnt = 0;
//Let's see if the element is present
siterator prev;
@ -3452,12 +3455,12 @@ class hashtable_impl
found_bucket = n_bucket;
//If it's present, find the first that it's not equal in
//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;
++internal_cnt; //At least one is found
if(optimize_multikey){
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{
siterator const bend = b.end();
@ -3468,7 +3471,7 @@ class hashtable_impl
to_return.second = it;
}
}
cnt = internal_cnt;
cnt = size_type(internal_cnt);
return to_return;
}
@ -3486,15 +3489,14 @@ class hashtable_impl
(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
//is not pointing to an element.
bucket_ptr const bp = this->priv_bucket_pointer();
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();
++n_bucket;
for( const size_type max_bucket = this->bucket_count()
; n_bucket != max_bucket
; ++n_bucket){
bucket_type &b = bp[n_bucket];
bucket_type &b = this->priv_bucket(n_bucket);
if(!b.empty()){
to_return.second = b.begin();
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_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(value_traits_ptr)
@ -103,7 +104,13 @@ struct pointer_traits
(boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t) difference_type;
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
{
@ -265,9 +272,10 @@ struct pointer_traits<Ptr&> : pointer_traits<Ptr> { };
template <typename T>
struct pointer_traits<T*>
{
typedef T element_type;
typedef T* pointer;
typedef std::ptrdiff_t difference_type;
typedef T element_type;
typedef T* pointer;
typedef std::ptrdiff_t difference_type;
typedef std::size_t size_type;
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
typedef T & reference;

154
test/generic_assoc_test.hpp
View File

@ -16,10 +16,10 @@
#include "common_functors.hpp"
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/detail/iterator.hpp>
#include <boost/core/lightweight_test.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
#include <boost/next_prior.hpp>
namespace boost{
namespace intrusive{
@ -90,7 +90,7 @@ void test_generic_assoc<ContainerDefiner>::test_insert_erase_burst()
const std::size_t MaxValues = 200;
value_cont_type values(MaxValues);
for(std::size_t i = 0; i != MaxValues; ++i){
(&values[i])->value_ = i;
(&values[i])->value_ = (int)i;
}
typedef typename ContainerDefiner::template container
@ -98,7 +98,7 @@ void test_generic_assoc<ContainerDefiner>::test_insert_erase_burst()
typedef typename assoc_type::iterator iterator;
{ //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());
testset.check();
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;
BOOST_TEST(values.size() == MaxValues);
for(std::size_t i = 0; i != MaxValues; ++i){
(&values[i])->value_ = i;
(&values[i])->value_ = (int)i;
}
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])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[4])
, value_traits_t::to_node_ptr(values[0])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check();
}
@ -228,26 +228,26 @@ void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
, value_traits_t::to_node_ptr(values[2])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[0])
, value_traits_t::to_node_ptr(values[2])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check();
}
@ -262,26 +262,26 @@ void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
, value_traits_t::to_node_ptr(values[5])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[1])
, value_traits_t::to_node_ptr(values[5])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check();
}
@ -296,26 +296,26 @@ void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
, value_traits_t::to_node_ptr(values[1])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[0])
, value_traits_t::to_node_ptr(values[1])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check();
}
@ -330,26 +330,26 @@ void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
, value_traits_t::to_node_ptr(values[2])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
node_algorithms_t::swap_nodes
( value_traits_t::to_node_ptr(values[1])
, value_traits_t::to_node_ptr(values[2])
);
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 0) == &values[0]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 1) == &values[1]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 2) == &values[2]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 3) == &values[3]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 4) == &values[4]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 5) == &values[5]) );
BOOST_TEST( (&*iterator_next(testset.begin(), 6) == &values[6]) );
testset.check();
}
@ -387,7 +387,7 @@ void test_generic_assoc<ContainerDefiner>::test_root(value_cont_type& values)
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 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::size_type size_type;
assoc_type testset1 (values.begin(), values.begin() + values.size());
assoc_type testset1 (values.begin(), values.end());
assoc_type testset2;
@ -436,7 +436,7 @@ void test_generic_assoc<ContainerDefiner>
{
typedef typename ContainerDefiner::template container
<>::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.cend()));
}

11
test/generic_multiset_test.hpp
View File

@ -10,8 +10,9 @@
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#include <boost/container/vector.hpp>
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/container/vector.hpp>
#include "common_functors.hpp"
#include <boost/core/lightweight_test.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 };
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];
typedef typename ContainerDefiner::template container
<>::type multiset_type;
@ -75,13 +76,13 @@ template<class ContainerDefiner>
void test_generic_multiset<ContainerDefiner>::test_impl()
{
value_cont_type values (5);
for (int i = 0; i < 5; ++i)
(&values[i])->value_ = i;
for (std::size_t i = 0u; i < 5u; ++i)
(&values[i])->value_ = (int)i;
typedef typename ContainerDefiner::template container
<>::type multiset_type;
multiset_type testset;
for (int i = 0; i < 5; ++i)
for (std::size_t i = 0; i < 5u; ++i)
testset.insert (values[i]);
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 };
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];
{
@ -80,8 +80,8 @@ void test_generic_set<ContainerDefiner>::test_all()
}
{
value_cont_type values(6);
for (int i = 0; i < 6; ++i)
(&values[i])->value_ = i+1;
for (std::size_t i = 0; i < 6u; ++i)
(&values[i])->value_ = (int)i+1;
set_type testset(values.begin(), values.end());
test::test_iterator_bidirectional(testset);
}
@ -92,13 +92,13 @@ template<class ContainerDefiner>
void test_generic_set<ContainerDefiner>::test_impl()
{
value_cont_type values (5);
for (int i = 0; i < 5; ++i)
(&values[i])->value_ = i;
for (std::size_t i = 0; i < 5u; ++i)
(&values[i])->value_ = (int)i;
typedef typename ContainerDefiner::template container
<>::type set_type;
set_type testset;
for (int i = 0; i < 5; ++i)
for (std::size_t i = 0; i < 5u; ++i)
testset.insert (values[i]);
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;
{
set_type testset;
testset.insert(values.begin(), values.begin() + values.size());
testset.insert(values.begin(), values.end());
testset.check();
value_type v(1);
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;
{
set_type testset;
testset.insert(values.begin(), values.begin() + values.size());
testset.insert(values.begin(), values.end());
testset.check();
value_type v(1);
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)
{
typedef typename C::size_type size_type;
typedef typename C::difference_type difference_type;
{
I it = b;
for(size_type i = 0, m = c.size(); i != m; ++i, ++it){
BOOST_TEST(i == size_type(it - b));
for(difference_type i = 0, m = difference_type(c.size()); i != m; ++i, ++it){
BOOST_TEST(i == it - b);
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)
{
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);
for(int s = 1; s <= num_values; ++s){
for(std::size_t s = 1u; s <= num_values; ++s){
expected_values.resize(s);
//Shift forward all possible positions 3 times
for(int i = 0; i < s*3; ++i){
testlist.insert(testlist.begin(), values.begin(), values.begin() + s);
for(std::size_t i = 0u; i < s*3u; ++i){
testlist.insert(testlist.begin(), values.begin(), values.begin() + std::ptrdiff_t(s));
testlist.shift_forward(i);
for(int j = 0; j < s; ++j){
expected_values[(j + s - i%s) % s] = (j + 1);
for(std::size_t j = 0u; j < s; ++j){
expected_values[(j + s - i%s) % s] = int(j + 1u);
}
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin());
testlist.clear();
}
//Shift backwards all possible positions
for(int i = 0; i < s*3; ++i){
testlist.insert(testlist.begin(), values.begin(), values.begin() + s);
for(std::size_t i = 0u; i < s*3u; ++i){
testlist.insert(testlist.begin(), values.begin(), values.begin() + std::ptrdiff_t(s));
testlist.shift_backwards(i);
for(int j = 0; j < s; ++j){
expected_values[(j + i) % s] = (j + 1);
for(std::size_t j = 0u; j < s; ++j){
expected_values[(j + i) % s] = int(j + 1);
}
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin());
testlist.clear();
@ -384,7 +384,7 @@ template < class ListType, typename ValueContainer >
void test_list< ListType, ValueContainer >
::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.cend()));
}
@ -393,7 +393,7 @@ template < class ListType, typename ValueContainer >
void test_list< ListType, ValueContainer >
::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;
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;
std::vector<value_type> data (5);
for (int i = 0; i < 5; ++i)
data[i].value_ = i + 1;
for (std::size_t i = 0u; i < 5u; ++i)
data[i].value_ = (int)i + 1;
make_and_test_list < typename detail::get_base_value_traits <
value_type,
@ -475,8 +475,8 @@ class test_main_template< VoidPointer, false, Default_Holder >
{
typedef testvalue< hooks<VoidPointer> > value_type;
std::vector<value_type> data (5);
for (int i = 0; i < 5; ++i)
data[i].value_ = i + 1;
for (std::size_t i = 0; i < 5u; ++i)
data[i].value_ = (int)i + 1;
make_and_test_list < typename detail::get_base_value_traits <
value_type,
@ -514,10 +514,10 @@ struct test_main_template_bptr
{
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);
new (tmp.raw()) value_type(i + 1);
new (tmp.raw()) value_type((int)i + 1);
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)
{
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);
//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);
for(int i = 0; i < s*3; ++i){
testlist.insert_after(testlist.before_begin(), values.begin(), values.begin() + s);
for(std::size_t i = 0; i < s*3u; ++i){
testlist.insert_after(testlist.before_begin(), values.begin(), values.begin() + std::ptrdiff_t(s));
testlist.shift_forward(i);
for(int j = 0; j < s; ++j){
expected_values[(j + s - i%s) % s] = (j + 1);
for(std::size_t j = 0; j < s; ++j){
expected_values[(j + s - i%s) % s] = int(j + 1);
}
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin())
@ -309,11 +309,11 @@ void test_slist< ListType, ValueContainer >
}
//Shift backwards all possible positions
for(int i = 0; i < s*3; ++i){
testlist.insert_after(testlist.before_begin(), values.begin(), values.begin() + s);
for(std::size_t i = 0; i < s*3u; ++i){
testlist.insert_after(testlist.before_begin(), values.begin(), values.begin() + std::ptrdiff_t(s));
testlist.shift_backwards(i);
for(int j = 0; j < s; ++j){
expected_values[(j + i) % s] = (j + 1);
for(std::size_t j = 0; j < s; ++j){
expected_values[(j + i) % s] = int(j + 1);
}
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin())
@ -463,7 +463,7 @@ template < typename ListType, typename ValueContainer >
void test_slist< ListType, ValueContainer >
::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;
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 >
::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.cend()));
}
@ -516,8 +516,8 @@ class test_main_template
{
typedef testvalue< hooks<VoidPointer> > value_type;
std::vector< value_type > data (5);
for (int i = 0; i < 5; ++i)
data[i].value_ = i + 1;
for (std::size_t i = 0; i < 5u; ++i)
data[i].value_ = (int)i + 1;
make_and_test_slist < typename detail::get_base_value_traits
< value_type
@ -590,8 +590,8 @@ class test_main_template<VoidPointer, false, Default_Holder>
{
typedef testvalue< hooks<VoidPointer> > value_type;
std::vector< value_type > data (5);
for (int i = 0; i < 5; ++i)
data[i].value_ = i + 1;
for (std::size_t i = 0; i < 5u; ++i)
data[i].value_ = (int)i + 1;
make_and_test_slist < typename detail::get_base_value_traits
< value_type
@ -659,10 +659,10 @@ struct test_main_template_bptr
{
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);
new (tmp.raw()) value_type(i + 1);
new (tmp.raw()) value_type((int)i + 1);
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();
size_type total_objects = 0;
std::size_t blen = c.bucket_count();
std::size_t total_objects = 0;
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() );
}

2
test/test_macros.hpp
View File

@ -25,7 +25,7 @@ struct is_multikey_true
{
typedef char yes_type;
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 two<U::is_multikey>test(int);
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 };
typedef typename ValueContainer< value_type >::type value_cont_type;
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];
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 };
typedef typename ValueContainer< value_type >::type value_cont_type;
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];
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 };
typedef typename ValueContainer< value_type >::type value_cont_type;
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];
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 };
typedef typename ValueContainer< value_type >::type value_cont_type;
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];
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 };
typedef typename ValueContainer< value_type >::type value_cont_type;
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];
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 };
typedef typename ValueContainer< value_type >::type value_cont_type;
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];
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);
for (int i = 0; i < (int)BucketSize; ++i)
(&vals[i])->value_ = i;
for (std::size_t i = 0; i < BucketSize; ++i)
(&vals[i])->value_ = (int)i;
typename unordered_type::bucket_type buckets [BucketSize];
unordered_type testset(bucket_traits(
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;
value_cont_type values (5);
for (int i = 0; i < 5; ++i)
values[i].value_ = i;
for (std::size_t i = 0u; i < 5u; ++i)
values[i].value_ = (int)i;
typename unordered_type::bucket_type buckets [BucketSize];
unordered_type testset(bucket_traits(
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.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
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];
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);
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];
unordered_type testset_new(bucket_traits(
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 unsigned int NumIterations = BucketSize*LoadFactor;
const std::size_t LoadFactor = 3;
const std::size_t NumIterations = BucketSize*LoadFactor;
value_cont_type random_init(NumIterations);//Preserve memory
value_cont_type set_tester;
set_tester.reserve(NumIterations);
//Initialize values
for (unsigned int i = 0; i < NumIterations; ++i){
random_init[i].value_ = i*2;//(i/LoadFactor)*LoadFactor;
for (std::size_t i = 0u; i < NumIterations; ++i){
random_init[i].value_ = (int)i*2;//(i/LoadFactor)*LoadFactor;
}
typename unordered_type::bucket_type buckets [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(unsigned int final_pos = initial_pos; final_pos != (NumIterations+1); ++final_pos){
for(std::size_t initial_pos = 0; initial_pos != (NumIterations+1u); ++initial_pos){
for(std::size_t final_pos = initial_pos; final_pos != (NumIterations+1); ++final_pos){
//Create intrusive container inserting values
unordered_type testset
@ -351,16 +351,16 @@ void test_unordered<ContainerDefiner>::test_insert(value_cont_type& values, deta
//Obtain the iterator range to erase
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;
}
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;
}
//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
testset.erase(it_beg_pos, it_end_pos);