diff --git a/example/doc_clone_from.cpp b/example/doc_clone_from.cpp index eeb844d..76b5f57 100644 --- a/example/doc_clone_from.cpp +++ b/example/doc_clone_from.cpp @@ -47,13 +47,13 @@ struct delete_disposer int main() { - const int MaxElem = 100; + const std::size_t MaxElem = 100; std::vector 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()); diff --git a/example/doc_iterator_from_value.cpp b/example/doc_iterator_from_value.cpp index c8105eb..c33d7dd 100644 --- a/example/doc_iterator_from_value.cpp +++ b/example/doc_iterator_from_value.cpp @@ -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 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; diff --git a/example/doc_offset_ptr.cpp b/example/doc_offset_ptr.cpp index f285ac7..4d322db 100644 --- a/example/doc_offset_ptr.cpp +++ b/example/doc_offset_ptr.cpp @@ -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(ip::anonymous_instance)(); diff --git a/example/doc_positional_insertion.cpp b/example/doc_positional_insertion.cpp index 5d628a0..5cf3451 100644 --- a/example/doc_positional_insertion.cpp +++ b/example/doc_positional_insertion.cpp @@ -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 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::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 > > 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 > >:: 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::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::const_iterator next(mset.cbegin()), it(next++); diff --git a/example/doc_treap_algorithms.cpp b/example/doc_treap_algorithms.cpp index 96ce48a..0c14a53 100644 --- a/example/doc_treap_algorithms.cpp +++ b/example/doc_treap_algorithms.cpp @@ -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_; diff --git a/example/doc_treap_set.cpp b/example/doc_treap_set.cpp index f8abbe5..b1b4a4b 100644 --- a/example/doc_treap_set.cpp +++ b/example/doc_treap_set.cpp @@ -66,7 +66,7 @@ int main() //Create several MyClass objects, each one with a different value std::vector 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; diff --git a/include/boost/intrusive/detail/iterator.hpp b/include/boost/intrusive/detail/iterator.hpp index 41ffca1..8d56c6c 100644 --- a/include/boost/intrusive/detail/iterator.hpp +++ b/include/boost/intrusive/detail/iterator.hpp @@ -142,25 +142,25 @@ struct iterator_disable_if_tag_difference_type // advance //////////////////// -template +template BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag::type - iterator_advance(InputIt& it, Distance n) + iterator_advance(InputIt& it, typename iterator_traits::difference_type n) { while(n--) ++it; } -template +template typename iterator_enable_if_tag::type - iterator_advance(InputIt& it, Distance n) + iterator_advance(InputIt& it, typename iterator_traits::difference_type n) { while(n--) ++it; } -template +template BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag::type - iterator_advance(InputIt& it, Distance n) + iterator_advance(InputIt& it, typename iterator_traits::difference_type n) { for (; 0 < n; --n) ++it; @@ -175,37 +175,37 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag +template BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag ::type - iterator_advance(InputIt& it, Distance n) + iterator_advance(InputIt& it, typename iterator_traits::difference_type n) { while(n--) ++it; } -template +template BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag ::type - iterator_advance(InputIt& it, Distance n) + iterator_advance(InputIt& it, typename iterator_traits::difference_type n) { while(n--) ++it; } -template +template BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag ::type - iterator_advance(InputIt& it, Distance n) + iterator_advance(InputIt& it, typename iterator_traits::difference_type n) { while(n--) ++it; } -template +template BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag ::type - iterator_advance(InputIt& it, Distance n) + iterator_advance(InputIt& it, typename iterator_traits::difference_type n) { for (; 0 < n; --n) ++it; @@ -215,17 +215,24 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag class fake{}; -template +template BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag ::type - iterator_advance(InputIt& it, Distance n) + iterator_advance(InputIt& it, typename iterator_traits::difference_type n) { it += n; } -//////////////////// -// distance -//////////////////// +template +BOOST_INTRUSIVE_FORCEINLINE + void iterator_uadvance(It& it, typename iterator_traits::size_type n) +{ + (iterator_advance)(it, (typename iterator_traits::difference_type)n); +} + +//////////////////////////////////////// +// iterator_distance +//////////////////////////////////////// template inline typename iterator_disable_if_tag_difference_type ::type @@ -248,6 +255,39 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type return off; } +//////////////////////////////////////// +// iterator_udistance +//////////////////////////////////////// + +template +BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits::size_type + iterator_udistance(It first, It last) +{ + return (typename iterator_traits::size_type)(iterator_distance)(first, last); +} + +//////////////////////////////////////// +// iterator_next +//////////////////////////////////////// + +template +BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iterator_traits::difference_type n) +{ + (iterator_advance)(it, n); + return it; +} + +template +BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iterator_traits::size_type n) +{ + (iterator_advance)(it, n); + return it; +} + +//////////////////////////////////////// +// iterator_arrow_result +//////////////////////////////////////// + template BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits::pointer iterator_arrow_result(const I &i) { return i.operator->(); } diff --git a/include/boost/intrusive/detail/math.hpp b/include/boost/intrusive/detail/math.hpp index c3d9e84..ff379f6 100644 --- a/include/boost/intrusive/detail/math.hpp +++ b/include/boost/intrusive/detail/math.hpp @@ -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 { static unsigned long call(unsigned long n) - { return __builtin_clzl(n); } + { return (unsigned long)__builtin_clzl(n); } }; template<> struct builtin_clz_dispatch { 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) diff --git a/include/boost/intrusive/detail/mpl.hpp b/include/boost/intrusive/detail/mpl.hpp index 935c04c..d86fa4f 100644 --- a/include/boost/intrusive/detail/mpl.hpp +++ b/include/boost/intrusive/detail/mpl.hpp @@ -155,7 +155,7 @@ template \ struct TRAITS_PREFIX##_bool\ {\ template\ - struct two_or_three {yes_type _[2 + Add];};\ + struct two_or_three {yes_type _[2u + (unsigned)Add];};\ template static yes_type test(...);\ template static two_or_three test (int);\ static const std::size_t value = sizeof(test(0));\ diff --git a/include/boost/intrusive/detail/reverse_iterator.hpp b/include/boost/intrusive/detail/reverse_iterator.hpp index 57631fe..00b0e5f 100644 --- a/include/boost/intrusive/detail/reverse_iterator.hpp +++ b/include/boost/intrusive/detail/reverse_iterator.hpp @@ -13,153 +13,16 @@ #ifndef BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP #define BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP -#ifndef BOOST_CONFIG_HPP -# include -#endif - -#if defined(BOOST_HAS_PRAGMA_ONCE) -# pragma once -#endif - -#include -#include -#include +#include namespace boost { namespace intrusive { -template -class reverse_iterator -{ - public: - typedef typename boost::intrusive::iterator_traits::pointer pointer; - typedef typename boost::intrusive::iterator_traits::reference reference; - typedef typename boost::intrusive::iterator_traits::difference_type difference_type; - typedef typename boost::intrusive::iterator_traits::iterator_category iterator_category; - typedef typename boost::intrusive::iterator_traits::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 - reverse_iterator( const reverse_iterator& r - , typename boost::intrusive::detail::enable_if_convertible::type* =0 - ) - : m_current(r.base()) - {} - - reverse_iterator & operator=( const reverse_iterator& r) - { m_current = r.base(); return *this; } - - template - typename boost::intrusive::detail::enable_if_convertible::type - operator=( const reverse_iterator& 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 #endif //BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP diff --git a/include/boost/intrusive/hashtable.hpp b/include/boost/intrusive/hashtable.hpp index 147cc8f..a580328 100644 --- a/include/boost/intrusive/hashtable.hpp +++ b/include/boost/intrusive/hashtable.hpp @@ -314,20 +314,20 @@ template struct store_hash_is_true { template - struct two_or_three {yes_type _[2 + Add];}; + struct two_or_three {yes_type _[2u + (unsigned)Add];}; template static yes_type test(...); template static two_or_three test (int); - static const bool value = sizeof(test(0)) > sizeof(yes_type)*2; + static const bool value = sizeof(test(0)) > sizeof(yes_type)*2u; }; template struct optimize_multikey_is_true { template - struct two_or_three {yes_type _[2 + Add];}; + struct two_or_three {yes_type _[2u + (unsigned)Add];}; template static yes_type test(...); template static two_or_three test (int); - static const bool value = sizeof(test(0)) > sizeof(yes_type)*2; + static const bool value = sizeof(test(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 - 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(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() - 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(it.pointed_node())); //Now get the bucket_impl from the iterator const bucket_type &b = static_cast (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(&b - &*f); + return static_cast(&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() - 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(&b - &*f); + return static_cast(&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 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_tcached_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_tbucket_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_tpriv_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_tcached_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 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() - - (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()); + , 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(); } + { 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::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::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)); } //! Requires: 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::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 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 (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 , slist_node_ptr, node_ptr > NodeDisposer; NodeDisposer node_disp(disposer, &this->priv_value_traits()); detail::exception_array_disposer - 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_()); - 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; diff --git a/include/boost/intrusive/pointer_traits.hpp b/include/boost/intrusive/pointer_traits.hpp index 548474b..1b2ed05 100644 --- a/include/boost/intrusive/pointer_traits.hpp +++ b/include/boost/intrusive/pointer_traits.hpp @@ -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::type) reference; + ( boost::intrusive::detail::, Ptr, size_type + , typename boost::move_detail:: + make_unsigned::type) size_type; + + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT + ( boost::intrusive::detail::, Ptr, reference + , typename boost::intrusive::detail::unvoid_ref::type) reference; // template struct rebind_pointer { @@ -265,9 +272,10 @@ struct pointer_traits : pointer_traits { }; template struct pointer_traits { - 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; diff --git a/test/generic_assoc_test.hpp b/test/generic_assoc_test.hpp index c12849e..e993ed3 100644 --- a/test/generic_assoc_test.hpp +++ b/test/generic_assoc_test.hpp @@ -16,10 +16,10 @@ #include "common_functors.hpp" #include #include +#include #include #include "test_macros.hpp" #include "test_container.hpp" -#include namespace boost{ namespace intrusive{ @@ -90,7 +90,7 @@ void test_generic_assoc::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::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::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::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::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::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::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::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::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::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 { 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())); } diff --git a/test/generic_multiset_test.hpp b/test/generic_multiset_test.hpp index c1f49a7..472bf42 100644 --- a/test/generic_multiset_test.hpp +++ b/test/generic_multiset_test.hpp @@ -10,8 +10,9 @@ // See http://www.boost.org/libs/intrusive for documentation. // ///////////////////////////////////////////////////////////////////////////// -#include #include + +#include #include "common_functors.hpp" #include #include @@ -44,7 +45,7 @@ void test_generic_multiset::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 void test_generic_multiset::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])); diff --git a/test/generic_set_test.hpp b/test/generic_set_test.hpp index 2c6ba09..1f544b1 100644 --- a/test/generic_set_test.hpp +++ b/test/generic_set_test.hpp @@ -52,7 +52,7 @@ void test_generic_set::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::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 void test_generic_set::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::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::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; diff --git a/test/iterator_test.hpp b/test/iterator_test.hpp index 486cdd8..725e28f 100644 --- a/test/iterator_test.hpp +++ b/test/iterator_test.hpp @@ -258,10 +258,11 @@ template 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); diff --git a/test/list_test.cpp b/test/list_test.cpp index b5250fe..a81b1f2 100644 --- a/test/list_test.cpp +++ b/test/list_test.cpp @@ -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 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(), test::delete_disposer()); @@ -434,8 +434,8 @@ class test_main_template { typedef testvalue< hooks > value_type; std::vector 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 > value_type; std::vector 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); } diff --git a/test/slist_test.cpp b/test/slist_test.cpp index a1344af..870e1da 100644 --- a/test/slist_test.cpp +++ b/test/slist_test.cpp @@ -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 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(), test::delete_disposer()); @@ -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 > 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 { typedef testvalue< hooks > 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); } diff --git a/test/test_container.hpp b/test/test_container.hpp index 804481a..36a6289 100644 --- a/test/test_container.hpp +++ b/test/test_container.hpp @@ -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() ); } diff --git a/test/test_macros.hpp b/test/test_macros.hpp index 1f72d97..f5c3dd5 100644 --- a/test/test_macros.hpp +++ b/test/test_macros.hpp @@ -25,7 +25,7 @@ struct is_multikey_true { typedef char yes_type; template - struct two { yes_type _[1+IsMultikey]; }; + struct two { yes_type _[1u+unsigned(IsMultikey)]; }; template static yes_type test(...); template static twotest(int); static const bool value = sizeof(test(0)) != sizeof(yes_type); diff --git a/test/unordered_multiset_test.cpp b/test/unordered_multiset_test.cpp index 35fb84c..aa544fd 100644 --- a/test/unordered_multiset_test.cpp +++ b/test/unordered_multiset_test.cpp @@ -75,7 +75,7 @@ class test_main_template::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 > testval_traits_t; @@ -102,7 +102,7 @@ class test_main_template::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 > testval_traits_t; @@ -130,7 +130,7 @@ class test_main_template::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 > testval_traits_t; diff --git a/test/unordered_set_test.cpp b/test/unordered_set_test.cpp index dab86dd..10c23e0 100644 --- a/test/unordered_set_test.cpp +++ b/test/unordered_set_test.cpp @@ -74,7 +74,7 @@ class test_main_template::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 > testval_traits_t; @@ -101,7 +101,7 @@ class test_main_template::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 > testval_traits_t; @@ -129,7 +129,7 @@ class test_main_template::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 > testval_traits_t; diff --git a/test/unordered_test.hpp b/test/unordered_test.hpp index 99d56f1..6be0127 100644 --- a/test/unordered_test.hpp +++ b/test/unordered_test.hpp @@ -72,8 +72,8 @@ void test_unordered::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::pointer_to(buckets[0]), BucketSize)); @@ -99,14 +99,14 @@ void test_unordered::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::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::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::pointer_to(single_bucket[0]), 1)); @@ -324,22 +324,22 @@ void test_unordered::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::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::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);