summaryrefslogtreecommitdiff
path: root/boost/intrusive
diff options
context:
space:
mode:
authorDongHun Kwak <dh0128.kwak@samsung.com>2019-12-05 06:12:59 (GMT)
committerDongHun Kwak <dh0128.kwak@samsung.com>2019-12-05 06:12:59 (GMT)
commitb8cf34c691623e4ec329053cbbf68522a855882d (patch)
tree34da08632a99677f6b79ecb65e5b655a5b69a67f /boost/intrusive
parent3fdc3e5ee96dca5b11d1694975a65200787eab86 (diff)
downloadboost-b8cf34c691623e4ec329053cbbf68522a855882d.zip
boost-b8cf34c691623e4ec329053cbbf68522a855882d.tar.gz
boost-b8cf34c691623e4ec329053cbbf68522a855882d.tar.bz2
Imported Upstream version 1.67.0upstream/1.67.0
Diffstat (limited to 'boost/intrusive')
-rw-r--r--boost/intrusive/detail/config_begin.hpp27
-rw-r--r--boost/intrusive/hashtable.hpp93
-rw-r--r--boost/intrusive/pointer_plus_bits.hpp15
3 files changed, 99 insertions, 36 deletions
diff --git a/boost/intrusive/detail/config_begin.hpp b/boost/intrusive/detail/config_begin.hpp
index cef8616..8bd57a3 100644
--- a/boost/intrusive/detail/config_begin.hpp
+++ b/boost/intrusive/detail/config_begin.hpp
@@ -17,33 +17,20 @@
#ifdef BOOST_MSVC
#pragma warning (push)
- //
- //'function' : resolved overload was found by argument-dependent lookup
- //A function found by argument-dependent lookup (Koenig lookup) was eventually
- //chosen by overload resolution.
- //
- //In Visual C++ .NET and earlier compilers, a different function would have
- //been called. To pick the original function, use an explicitly qualified name.
- //
-
- //warning C4275: non dll-interface class 'x' used as base for
- //dll-interface class 'Y'
- #pragma warning (disable : 4275)
- //warning C4251: 'x' : class 'y' needs to have dll-interface to
- //be used by clients of class 'z'
- #pragma warning (disable : 4251)
- #pragma warning (disable : 4675)
- #pragma warning (disable : 4996)
- #pragma warning (disable : 4503)
+ #pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"
+ #pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
+ #pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter
+ #pragma warning (disable : 4996) // "function": was declared deprecated
+ #pragma warning (disable : 4503) // "identifier" : decorated name length exceeded, name was truncated
#pragma warning (disable : 4284) // odd return type for operator->
#pragma warning (disable : 4244) // possible loss of data
#pragma warning (disable : 4521) ////Disable "multiple copy constructors specified"
#pragma warning (disable : 4127) //conditional expression is constant
- #pragma warning (disable : 4146)
+ #pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
#pragma warning (disable : 4267) //conversion from 'X' to 'Y', possible loss of data
#pragma warning (disable : 4541) //'typeid' used on polymorphic type 'boost::exception' with /GR-
#pragma warning (disable : 4512) //'typeid' used on polymorphic type 'boost::exception' with /GR-
- #pragma warning (disable : 4522)
+ #pragma warning (disable : 4522) // "class" : multiple assignment operators specified
#pragma warning (disable : 4706) //assignment within conditional expression
#pragma warning (disable : 4710) // function not inlined
#pragma warning (disable : 4714) // "function": marked as __forceinline not inlined
diff --git a/boost/intrusive/hashtable.hpp b/boost/intrusive/hashtable.hpp
index 6b1d5dd..258e601 100644
--- a/boost/intrusive/hashtable.hpp
+++ b/boost/intrusive/hashtable.hpp
@@ -115,26 +115,89 @@ bool priv_algo_is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, F
template<int Dummy = 0>
struct prime_list_holder
{
+ private:
+
+ template <class SizeType> // sizeof(SizeType) < sizeof(std::size_t)
+ static BOOST_INTRUSIVE_FORCEINLINE SizeType truncate_size_type(std::size_t n, detail::true_)
+ {
+ return n < std::size_t(SizeType(-1)) ? static_cast<SizeType>(n) : SizeType(-1);
+ }
+
+ template <class SizeType> // sizeof(SizeType) == sizeof(std::size_t)
+ static BOOST_INTRUSIVE_FORCEINLINE SizeType truncate_size_type(std::size_t n, detail::false_)
+ {
+ return static_cast<SizeType>(n);
+ }
+
+ template <class SizeType> //sizeof(SizeType) > sizeof(std::size_t)
+ static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count_dispatch(SizeType n, detail::true_)
+ {
+ std::size_t const c = n > std::size_t(-1)
+ ? std::size_t(-1)
+ : suggested_upper_bucket_count_impl(static_cast<std::size_t>(n));
+ return static_cast<SizeType>(c);
+ }
+
+ template <class SizeType> //sizeof(SizeType) > sizeof(std::size_t)
+ static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count_dispatch(SizeType n, detail::true_)
+ {
+ std::size_t const c = n > std::size_t(-1)
+ ? std::size_t(-1)
+ : suggested_lower_bucket_count_impl(static_cast<std::size_t>(n));
+ return static_cast<SizeType>(c);
+ }
+
+ template <class SizeType>
+ static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count_dispatch(SizeType n, detail::false_)
+ {
+ std::size_t const c = suggested_upper_bucket_count_impl(static_cast<std::size_t>(n));
+ return truncate_size_type<SizeType>(c, detail::bool_<(sizeof(SizeType) < sizeof(std::size_t))>());
+
+ }
+
+ template <class SizeType>
+ static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count_dispatch(SizeType n, detail::false_)
+ {
+ std::size_t const c = suggested_lower_bucket_count_impl(static_cast<std::size_t>(n));
+ return truncate_size_type<SizeType>(c, detail::bool_<(sizeof(SizeType) < sizeof(std::size_t))>());
+ }
+
static const std::size_t prime_list[];
static const std::size_t prime_list_size;
- static std::size_t suggested_upper_bucket_count(std::size_t n)
+ static std::size_t suggested_lower_bucket_count_impl(std::size_t n)
{
const std::size_t *primes = &prime_list_holder<0>::prime_list[0];
const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
std::size_t const* bound = std::lower_bound(primes, primes_end, n);
- bound -= (bound == primes_end);
+ //Tables have upper SIZE_MAX, so we must always found an entry
+ BOOST_INTRUSIVE_INVARIANT_ASSERT(bound != primes_end);
+ bound -= std::size_t(bound != primes);
return *bound;
}
- static std::size_t suggested_lower_bucket_count(std::size_t n)
+ static std::size_t suggested_upper_bucket_count_impl(std::size_t n)
{
const std::size_t *primes = &prime_list_holder<0>::prime_list[0];
const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
std::size_t const* bound = std::upper_bound(primes, primes_end, n);
- bound -= (bound != primes);
+ bound -= std::size_t(bound == primes_end);
return *bound;
}
+
+ public:
+
+ template <class SizeType>
+ static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count(SizeType n)
+ {
+ return (suggested_upper_bucket_count_dispatch)(n, detail::bool_<(sizeof(SizeType) > sizeof(std::size_t))>());
+ }
+
+ template <class SizeType>
+ static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count(SizeType n)
+ {
+ return (suggested_lower_bucket_count_dispatch)(n, detail::bool_<(sizeof(SizeType) > sizeof(std::size_t))>());
+ }
};
#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
@@ -184,9 +247,9 @@ const std::size_t prime_list_holder<Dummy>::prime_list[] = {
BOOST_INTRUSIVE_PRIME_C(432345564227567621), BOOST_INTRUSIVE_PRIME_C(864691128455135207),
BOOST_INTRUSIVE_PRIME_C(1729382256910270481), BOOST_INTRUSIVE_PRIME_C(3458764513820540933),
BOOST_INTRUSIVE_PRIME_C(6917529027641081903), BOOST_INTRUSIVE_PRIME_C(13835058055282163729),
- BOOST_INTRUSIVE_PRIME_C(18446744073709551557)
+ BOOST_INTRUSIVE_PRIME_C(18446744073709551557), BOOST_INTRUSIVE_PRIME_C(18446744073709551615) //Upper limit, just in case
#else
- BOOST_INTRUSIVE_PRIME_C(4294967291)
+ BOOST_INTRUSIVE_PRIME_C(4294967291), BOOST_INTRUSIVE_PRIME_C(4294967295) //Upper limit, just in case
#endif
};
@@ -1476,16 +1539,12 @@ struct hashdata_internal
static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_upper_bucket_count(size_type n)
{
- std::size_t c = prime_list_holder<0>::suggested_upper_bucket_count
- (sizeof(size_type) > sizeof(std::size_t) && n > std::size_t(-1) ? std::size_t(-1) : static_cast<std::size_t>(n));
- return sizeof(size_type) < sizeof(std::size_t) && c > size_type(-1) ? size_type(-1) : static_cast<size_type>(c);
+ return prime_list_holder<0>::suggested_upper_bucket_count(n);
}
static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_lower_bucket_count(size_type n)
{
- std::size_t c = prime_list_holder<0>::suggested_lower_bucket_count
- (sizeof(size_type) > sizeof(std::size_t) && n > std::size_t(-1) ? std::size_t(-1) : static_cast<std::size_t>(n));
- return sizeof(size_type) < sizeof(std::size_t) && c > size_type(-1) ? size_type(-1) : static_cast<size_type>(c);
+ return prime_list_holder<0>::suggested_lower_bucket_count(n);
}
const_local_iterator cbegin(size_type n) const
@@ -1497,6 +1556,7 @@ struct hashdata_internal
using internal_type::end;
using internal_type::cend;
+
local_iterator end(size_type n)
{ return local_iterator(this->priv_bucket_pointer()[n].end(), this->priv_value_traits_ptr()); }
@@ -3370,7 +3430,7 @@ class hashtable_impl
, size_type &found_bucket
, size_type &cnt) const
{
- cnt = 0;
+ size_type internal_cnt = 0;
//Let's see if the element is present
siterator prev;
@@ -3386,20 +3446,21 @@ class hashtable_impl
//the same bucket
bucket_type &b = this->priv_bucket_pointer()[n_bucket];
siterator it = to_return.first;
- ++cnt; //At least one is found
+ ++internal_cnt; //At least one is found
if(optimize_multikey){
to_return.second = ++(priv_last_in_group)(it);
- cnt += boost::intrusive::iterator_distance(++it, to_return.second);
+ internal_cnt += boost::intrusive::iterator_distance(++it, to_return.second);
}
else{
siterator const bend = b.end();
while(++it != bend &&
this->priv_is_value_equal_to_key(this->priv_value_from_slist_node(it.pointed_node()), h, key, equal_func)){
- ++cnt;
+ ++internal_cnt;
}
to_return.second = it;
}
}
+ cnt = internal_cnt;
return to_return;
}
diff --git a/boost/intrusive/pointer_plus_bits.hpp b/boost/intrusive/pointer_plus_bits.hpp
index dfde66b..a39da32 100644
--- a/boost/intrusive/pointer_plus_bits.hpp
+++ b/boost/intrusive/pointer_plus_bits.hpp
@@ -22,6 +22,17 @@
# pragma once
#endif
+
+//GCC reports uninitialized values when an uninitialized pointer plus bits type
+//is asigned some bits or some pointer value, but that's ok, because we don't want
+//to default initialize parts that are not being updated.
+#if defined(BOOST_GCC)
+# if (BOOST_GCC >= 40600)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wuninitialized"
+# endif
+#endif
+
namespace boost {
namespace intrusive {
@@ -89,6 +100,10 @@ struct pointer_plus_bits<T*, NumBits>
} //namespace intrusive
} //namespace boost
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+# pragma GCC diagnostic pop
+#endif
+
#include <boost/intrusive/detail/config_end.hpp>
#endif //BOOST_INTRUSIVE_POINTER_PLUS_BITS_HPP