Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r74750 - in trunk/boost/unordered: . detail
From: dnljms_at_[hidden]
Date: 2011-10-06 04:03:28

Next message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r74751 - trunk/libs/timer/test"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r74749 - in trunk/boost/chrono: io stopwatches stopwatches/collectors"

Author: danieljames
Date: 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
New Revision: 74750
URL: http://svn.boost.org/trac/boost/changeset/74750

Log:
Unordered: Better emplace_args implementation.

And some misc. cleanup.
Text files modified:
   trunk/boost/unordered/detail/allocator_helpers.hpp | 253 ++++++++++++++-------------
   trunk/boost/unordered/detail/buckets.hpp | 109 ++++++----
   trunk/boost/unordered/detail/emplace_args.hpp | 366 +++++++++++++--------------------------
   trunk/boost/unordered/detail/equivalent.hpp | 80 ++++----
   trunk/boost/unordered/detail/extract_key.hpp | 2
   trunk/boost/unordered/detail/table.hpp | 78 ++++----
   trunk/boost/unordered/detail/unique.hpp | 78 ++++----
   trunk/boost/unordered/detail/util.hpp | 22 +-
   trunk/boost/unordered/unordered_map.hpp | 56 +++---
   trunk/boost/unordered/unordered_map_fwd.hpp | 10
   trunk/boost/unordered/unordered_set.hpp | 56 +++---
   trunk/boost/unordered/unordered_set_fwd.hpp | 10
   12 files changed, 510 insertions(+), 610 deletions(-)

Modified: trunk/boost/unordered/detail/allocator_helpers.hpp
==============================================================================
--- trunk/boost/unordered/detail/allocator_helpers.hpp (original)
+++ trunk/boost/unordered/detail/allocator_helpers.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -24,32 +24,40 @@
#include <boost/type_traits/add_lvalue_reference.hpp>
#include <boost/pointer_to_other.hpp>
#include <boost/assert.hpp>
+#include <boost/utility/addressof.hpp>

#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
# include <memory>
#endif

#if !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
-#include <type_traits>
+# include <type_traits>
+#endif
+
namespace boost { namespace unordered { namespace detail {
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Integral_constrant, true_type, false_type
+ //
+ // Uses the standard versions if available.
+
+#if !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
+
 using std::integral_constant;
 using std::true_type;
 using std::false_type;
-}}}
+
#else
-namespace boost { namespace unordered { namespace detail {
+
 template <typename T, T Value>
 struct integral_constant { enum { value = Value }; };
- typedef integral_constant<bool, true> true_type;
- typedef integral_constant<bool, false> false_type;
-}}}
-#endif

-// TODO: Use std::addressof if available?
-#include <boost/utility/addressof.hpp>
+ typedef boost::unordered::detail::integral_constant<bool, true> true_type;
+ typedef boost::unordered::detail::integral_constant<bool, false> false_type;

-namespace boost { namespace unordered { namespace detail {
+#endif

+ ////////////////////////////////////////////////////////////////////////////
 // Explicitly call a destructor

#if defined(BOOST_MSVC)
@@ -66,27 +74,10 @@
#pragma warning(pop)
#endif

-#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
- template <typename Alloc>
- struct allocator_traits : std::allocator_traits<Alloc> {};
-
- template <typename Alloc, typename T>
- struct rebind_wrap
- {
- typedef typename allocator_traits<Alloc>::rebind_alloc<T> type;
- };
-#else
- // rebind_wrap
+ ////////////////////////////////////////////////////////////////////////////
+ // Bits and pieces for implementing traits
 //
- // Rebind allocators. For some problematic libraries, use rebind_to
- // from <boost/detail/allocator_utilities.hpp>.
-
- template <typename Alloc, typename T>
- struct rebind_wrap
- {
- typedef typename Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
- type;
- };
+ // Some of these are also used elsewhere

 template <typename T> typename boost::add_lvalue_reference<T>::type make();
 struct choice9 { typedef char (&type)[9]; };
@@ -116,67 +107,6 @@
 convert_from_anything(...);
 };

-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
-
- #define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
- template <typename Tp, typename Default> \
- struct default_type_ ## tname { \
- \
- template <typename X> \
- static choice1::type test(choice1, typename X::tname* = 0); \
- \
- template <typename X> \
- static choice2::type test(choice2, void* = 0); \
- \
- struct DefaultWrap { typedef Default tname; }; \
- \
- enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
- \
- typedef typename boost::detail::if_true<value>:: \
- BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
- ::type::tname type; \
- }
-
-#else
-
- template <typename T, typename T2>
- struct sfinae : T2 {};
-
- #define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
- template <typename Tp, typename Default> \
- struct default_type_ ## tname { \
- \
- template <typename X> \
- static typename sfinae<typename X::tname, choice1>::type \
- test(choice1); \
- \
- template <typename X> \
- static choice2::type test(choice2); \
- \
- struct DefaultWrap { typedef Default tname; }; \
- \
- enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
- \
- typedef typename boost::detail::if_true<value>:: \
- BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
- ::type::tname type; \
- }
-
-#endif
-
- #define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg) \
- typename default_type_ ## tname<T, arg>::type
-
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
-
#if !defined(BOOST_NO_SFINAE_EXPR) || BOOST_WORKAROUND(BOOST_MSVC, >= 1500)

# define BOOST_UNORDERED_HAVE_CALL_0_DETECTION 1
@@ -188,9 +118,11 @@

#define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression) \
 template <typename U> \
- static typename expr_test< \
+ static typename boost::unordered::detail::expr_test< \
 BOOST_PP_CAT(choice, result), \
- sizeof(for_expr_test(((expression), 0)))>::type test( \
+ sizeof(boost::unordered::detail::for_expr_test(( \
+ (expression), \
+ 0)))>::type test( \
 BOOST_PP_CAT(choice, count))

#define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result) \
@@ -273,9 +205,10 @@
 template <typename U> \
 struct impl \
 { \
- enum { value = sizeof(is_private_type(( \
- make<wrap< thing > >().name args \
- , 0))) == sizeof(yes_type) }; \
+ enum { value = sizeof( \
+ boost::unordered::detail::is_private_type(( \
+ make<wrap< thing > >().name args \
+ , 0))) == sizeof(yes_type) }; \
 }; \
 \
 enum { value = \
@@ -286,6 +219,95 @@

#endif

+ ////////////////////////////////////////////////////////////////////////////
+ // Allocator traits
+ //
+ // Uses the standard versions if available.
+ // (although untested as I don't have access to a standard version yet)
+
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
+
+ template <typename Alloc>
+ struct allocator_traits : std::allocator_traits<Alloc> {};
+
+ template <typename Alloc, typename T>
+ struct rebind_wrap
+ {
+ typedef typename std::allocator_traits<Alloc>::rebind_alloc<T> type;
+ };
+
+#else
+
+ // TODO: Does this match std::allocator_traits<Alloc>::rebind_alloc<T>?
+ template <typename Alloc, typename T>
+ struct rebind_wrap
+ {
+ typedef typename Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
+ type;
+ };
+
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
+
+ #define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
+ template <typename Tp, typename Default> \
+ struct default_type_ ## tname { \
+ \
+ template <typename X> \
+ static choice1::type test(choice1, typename X::tname* = 0); \
+ \
+ template <typename X> \
+ static choice2::type test(choice2, void* = 0); \
+ \
+ struct DefaultWrap { typedef Default tname; }; \
+ \
+ enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
+ \
+ typedef typename boost::detail::if_true<value>:: \
+ BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
+ ::type::tname type; \
+ }
+
+#else
+
+ template <typename T, typename T2>
+ struct sfinae : T2 {};
+
+ #define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
+ template <typename Tp, typename Default> \
+ struct default_type_ ## tname { \
+ \
+ template <typename X> \
+ static typename boost::unordered::detail::sfinae< \
+ typename X::tname, choice1>::type \
+ test(choice1); \
+ \
+ template <typename X> \
+ static choice2::type test(choice2); \
+ \
+ struct DefaultWrap { typedef Default tname; }; \
+ \
+ enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
+ \
+ typedef typename boost::detail::if_true<value>:: \
+ BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
+ ::type::tname type; \
+ }
+
+#endif
+
+ #define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg) \
+ typename default_type_ ## tname<T, arg>::type
+
+ BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
+ BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
+ BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
+ BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
+ BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
+ BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
+ BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
+ BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
+ BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
+
#if BOOST_UNORDERED_HAVE_CALL_0_DETECTION
 template <typename T>
 BOOST_UNORDERED_HAS_FUNCTION(
@@ -425,7 +447,7 @@
 static void destroy(Alloc&, T* p, typename
 boost::disable_if<has_destroy<Alloc, T>, void*>::type = 0)
 {
- ::boost::unordered::detail::destroy(p);
+ boost::unordered::detail::destroy(p);
 }

 static size_type max_size(const Alloc& a)
@@ -453,6 +475,10 @@
 Alloc,propagate_on_container_swap,false_type)
 propagate_on_container_swap;
 };
+
+#undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
+#undef BOOST_UNORDERED_DEFAULT_TYPE
+
#endif

 // array_constructor
@@ -464,8 +490,8 @@
 template <typename Allocator>
 struct array_constructor
 {
- typedef typename allocator_traits<Allocator>::pointer
- pointer;
+ typedef boost::unordered::detail::allocator_traits<Allocator> traits;
+ typedef typename traits::pointer pointer;

 Allocator& alloc_;
 pointer ptr_;
@@ -482,10 +508,9 @@
 ~array_constructor() {
 if (ptr_) {
 for(pointer p = ptr_; p != constructed_; ++p)
- allocator_traits<Allocator>::destroy(alloc_,
- boost::addressof(*p));
+ traits::destroy(alloc_, boost::addressof(*p));

- allocator_traits<Allocator>::deallocate(alloc_, ptr_, length_);
+ traits::deallocate(alloc_, ptr_, length_);
 }
 }

@@ -494,11 +519,10 @@
 {
 BOOST_ASSERT(!ptr_);
 length_ = l;
- ptr_ = allocator_traits<Allocator>::allocate(alloc_, length_);
+ ptr_ = traits::allocate(alloc_, length_);
 pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
 for(constructed_ = ptr_; constructed_ != end; ++constructed_)
- allocator_traits<Allocator>::construct(alloc_,
- boost::addressof(*constructed_), v);
+ traits::construct(alloc_, boost::addressof(*constructed_), v);
 }

 pointer get() const
@@ -514,25 +538,8 @@
 }
 private:
 array_constructor(array_constructor const&);
- array_constructor& operator=(
- array_constructor const&);
+ array_constructor& operator=(array_constructor const&);
 };
}}}

-#undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
-#undef BOOST_UNORDERED_DEFAULT_TYPE
-#undef BOOST_UNORDERED_HAVE_CALL_0_DETECTION
-#undef BOOST_UNORDERED_HAVE_CALL_N_DETECTION
-#undef BOOST_UNORDERED_HAS_FUNCTION
-#if defined(BOOST_UNORDERED_CHECK_EXPRESSION)
-# undef BOOST_UNORDERED_CHECK_EXPRESSION
-# undef BOOST_UNORDERED_DEFAULT_EXPRESSION
-#endif
-#if defined(BOOST_UNORDERED_HAS_MEMBER)
-# undef BOOST_UNORDERED_HAS_MEMBER
-# undef BOOST_UNORDERED_CHECK_MEMBER
-# undef BOOST_UNORDERED_DEFAULT_MEMBER
-# undef BOOST_UNORDERED_WRAP_PARAMATERS
-#endif
-
#endif

Modified: trunk/boost/unordered/detail/buckets.hpp
==============================================================================
--- trunk/boost/unordered/detail/buckets.hpp (original)
+++ trunk/boost/unordered/detail/buckets.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -16,6 +16,7 @@
#include <boost/unordered/detail/emplace_args.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/type_traits/alignment_of.hpp>
+#include <boost/swap.hpp>
#include <boost/assert.hpp>

#if defined(BOOST_MSVC)
@@ -28,7 +29,7 @@
 template <typename Types> struct table;
 template <typename NodePointer> struct bucket;
 struct ptr_bucket;
- template <typename Allocator, typename Bucket, typename Node> struct buckets;
+ template <typename A, typename Bucket, typename Node> struct buckets;

 ///////////////////////////////////////////////////////////////////
 //
@@ -40,7 +41,8 @@
 private:

 typedef NodeAlloc node_allocator;
- typedef ::boost::unordered::detail::allocator_traits<NodeAlloc> node_allocator_traits;
+ typedef boost::unordered::detail::allocator_traits<NodeAlloc>
+ node_allocator_traits;
 typedef typename node_allocator_traits::value_type node;
 typedef typename node_allocator_traits::pointer node_pointer;
 typedef typename node::value_type value_type;
@@ -68,9 +70,8 @@
 void construct_value(BOOST_UNORDERED_EMPLACE_ARGS)
 {
 BOOST_ASSERT(node_ && node_constructed_ && !value_constructed_);
- ::boost::unordered::detail::construct_impl<value_type>(
- node_->value_ptr(),
- BOOST_UNORDERED_EMPLACE_FORWARD);
+ boost::unordered::detail::construct_impl(
+ node_->value_ptr(), BOOST_UNORDERED_EMPLACE_FORWARD);
 value_constructed_ = true;
 }

@@ -78,7 +79,7 @@
 void construct_value2(BOOST_FWD_REF(A0) a0)
 {
 BOOST_ASSERT(node_ && node_constructed_ && !value_constructed_);
- ::boost::unordered::detail::construct_impl2<value_type>(
+ boost::unordered::detail::construct_impl2(
 node_->value_ptr(), boost::forward<A0>(a0));
 value_constructed_ = true;
 }
@@ -106,11 +107,12 @@
 {
 if (node_) {
 if (value_constructed_) {
- ::boost::unordered::detail::destroy(node_->value_ptr());
+ boost::unordered::detail::destroy(node_->value_ptr());
 }

 if (node_constructed_) {
- node_allocator_traits::destroy(alloc_, boost::addressof(*node_));
+ node_allocator_traits::destroy(alloc_,
+ boost::addressof(*node_));
 }

 node_allocator_traits::deallocate(alloc_, node_, 1);
@@ -126,7 +128,8 @@

 node_ = node_allocator_traits::allocate(alloc_, 1);

- node_allocator_traits::construct(alloc_, boost::addressof(*node_), node());
+ node_allocator_traits::construct(alloc_,
+ boost::addressof(*node_), node());
 node_->init(static_cast<typename node::link_pointer>(node_));
 node_constructed_ = true;
 }
@@ -135,7 +138,7 @@

 if (value_constructed_)
 {
- ::boost::unordered::detail::destroy(node_->value_ptr());
+ boost::unordered::detail::destroy(node_->value_ptr());
 value_constructed_ = false;
 }
 }
@@ -187,28 +190,38 @@
 buckets(buckets const&);
 buckets& operator=(buckets const&);
 public:
- typedef ::boost::unordered::detail::allocator_traits<A> traits;
+ typedef boost::unordered::detail::allocator_traits<A> traits;
 typedef typename traits::value_type value_type;
 typedef typename traits::void_pointer void_pointer;

 typedef Node node;
 typedef Bucket bucket;
- typedef typename ::boost::unordered::detail::rebind_wrap<A, node>::type node_allocator;
- typedef typename ::boost::unordered::detail::rebind_wrap<A, bucket>::type bucket_allocator;
- typedef ::boost::unordered::detail::allocator_traits<node_allocator> node_allocator_traits;
- typedef ::boost::unordered::detail::allocator_traits<bucket_allocator> bucket_allocator_traits;
- typedef typename node_allocator_traits::pointer node_pointer;
- typedef typename node_allocator_traits::const_pointer const_node_pointer;
- typedef typename bucket_allocator_traits::pointer bucket_pointer;
- typedef typename bucket::previous_pointer previous_pointer;
- typedef ::boost::unordered::detail::node_constructor<node_allocator> node_constructor;
+ typedef typename boost::unordered::detail::rebind_wrap<A, node>::type
+ node_allocator;
+ typedef typename boost::unordered::detail::rebind_wrap<A, bucket>::type
+ bucket_allocator;
+ typedef boost::unordered::detail::allocator_traits<node_allocator>
+ node_allocator_traits;
+ typedef boost::unordered::detail::allocator_traits<bucket_allocator>
+ bucket_allocator_traits;
+ typedef typename node_allocator_traits::pointer
+ node_pointer;
+ typedef typename node_allocator_traits::const_pointer
+ const_node_pointer;
+ typedef typename bucket_allocator_traits::pointer
+ bucket_pointer;
+ typedef typename bucket::previous_pointer
+ previous_pointer;
+ typedef boost::unordered::detail::node_constructor<node_allocator>
+ node_constructor;

 // Members

 bucket_pointer buckets_;
 std::size_t bucket_count_;
 std::size_t size_;
- ::boost::unordered::detail::compressed<bucket_allocator, node_allocator> allocators_;
+ boost::unordered::detail::compressed<bucket_allocator, node_allocator>
+ allocators_;

 // Data access

@@ -235,7 +248,8 @@
 std::size_t max_bucket_count() const
 {
 // -1 to account for the start bucket.
- return prev_prime(bucket_allocator_traits::max_size(bucket_alloc()) - 1);
+ return boost::unordered::detail::prev_prime(
+ bucket_allocator_traits::max_size(bucket_alloc()) - 1);
 }

 bucket_pointer get_bucket(std::size_t bucket_index) const
@@ -261,7 +275,8 @@
 node_pointer get_start(std::size_t bucket_index) const
 {
 previous_pointer prev = this->get_previous_start(bucket_index);
- return prev ? static_cast<node_pointer>(prev->next_) : node_pointer();
+ return prev ? static_cast<node_pointer>(prev->next_) :
+ node_pointer();
 }

 float load_factor() const
@@ -298,7 +313,7 @@
 {
 }

- buckets(buckets& b, ::boost::unordered::detail::move_tag m) :
+ buckets(buckets& b, boost::unordered::detail::move_tag m) :
 buckets_(),
 bucket_count_(b.bucket_count_),
 size_(),
@@ -308,8 +323,8 @@
 }

 template <typename Types>
- buckets(::boost::unordered::detail::table<Types>& x,
- ::boost::unordered::detail::move_tag m) :
+ buckets(boost::unordered::detail::table<Types>& x,
+ boost::unordered::detail::move_tag m) :
 buckets_(),
 bucket_count_(x.bucket_count_),
 size_(),
@@ -324,7 +339,7 @@

 void create_buckets()
 {
- ::boost::unordered::detail::array_constructor<bucket_allocator>
+ boost::unordered::detail::array_constructor<bucket_allocator>
 constructor(bucket_alloc());

 // Creates an extra bucket to act as the start node.
@@ -335,8 +350,9 @@
 node_constructor a(this->node_alloc());
 a.construct_node();

- (constructor.get() + static_cast<std::ptrdiff_t>(this->bucket_count_))->next_ =
- a.release();
+ (constructor.get() +
+ static_cast<std::ptrdiff_t>(this->bucket_count_))->next_ =
+ a.release();
 }

 this->buckets_ = constructor.release();
@@ -348,17 +364,17 @@
 void swap(buckets& other, false_type = false_type())
 {
 BOOST_ASSERT(node_alloc() == other.node_alloc());
- std::swap(buckets_, other.buckets_);
- std::swap(bucket_count_, other.bucket_count_);
- std::swap(size_, other.size_);
+ boost::swap(buckets_, other.buckets_);
+ boost::swap(bucket_count_, other.bucket_count_);
+ boost::swap(size_, other.size_);
 }

 void swap(buckets& other, true_type)
 {
 allocators_.swap(other.allocators_);
- std::swap(buckets_, other.buckets_);
- std::swap(bucket_count_, other.bucket_count_);
- std::swap(size_, other.size_);
+ boost::swap(buckets_, other.buckets_);
+ boost::swap(bucket_count_, other.bucket_count_);
+ boost::swap(size_, other.size_);
 }

 void move_buckets_from(buckets& other)
@@ -378,7 +394,7 @@

 inline void delete_node(node_pointer n)
 {
- ::boost::unordered::detail::destroy(n->value_ptr());
+ boost::unordered::detail::destroy(n->value_ptr());
 node_allocator_traits::destroy(node_alloc(), boost::addressof(*n));
 node_allocator_traits::deallocate(node_alloc(), n, 1);
 --size_;
@@ -426,10 +442,12 @@
 bucket_pointer end = this->get_bucket(this->bucket_count_ + 1);
 for(bucket_pointer it = this->buckets_; it != end; ++it)
 {
- bucket_allocator_traits::destroy(bucket_alloc(), boost::addressof(*it));
+ bucket_allocator_traits::destroy(bucket_alloc(),
+ boost::addressof(*it));
 }

- bucket_allocator_traits::deallocate(bucket_alloc(), this->buckets_, this->bucket_count_ + 1);
+ bucket_allocator_traits::deallocate(bucket_alloc(),
+ this->buckets_, this->bucket_count_ + 1);

 this->buckets_ = bucket_pointer();
 }
@@ -460,7 +478,8 @@

 // This is called after erasing a node or group of nodes to fix up
 // the bucket pointers.
- void fix_buckets(bucket_pointer bucket, previous_pointer prev, node_pointer next)
+ void fix_buckets(bucket_pointer bucket,
+ previous_pointer prev, node_pointer next)
 {
 if (!next)
 {
@@ -481,8 +500,8 @@

 // This is called after erasing a range of nodes to fix any bucket
 // pointers into that range.
- void fix_buckets_range(
- std::size_t bucket_index, previous_pointer prev, node_pointer begin, node_pointer end)
+ void fix_buckets_range(std::size_t bucket_index,
+ previous_pointer prev, node_pointer begin, node_pointer end)
 {
 node_pointer n = begin;

@@ -550,9 +569,9 @@

 typedef compressed<H, P> function_pair;

- typedef typename ::boost::aligned_storage<
+ typedef typename boost::aligned_storage<
 sizeof(function_pair),
- ::boost::alignment_of<function_pair>::value>::type aligned_function;
+ boost::alignment_of<function_pair>::value>::type aligned_function;

 bool current_; // The currently active functions.
 aligned_function funcs_[2];
@@ -574,7 +593,7 @@

 void destroy(bool which)
 {
- ::boost::unordered::detail::destroy((function_pair*)(&funcs_[which]));
+ boost::unordered::detail::destroy((function_pair*)(&funcs_[which]));
 }

 public:
@@ -592,7 +611,7 @@
 }

 ~functions() {
- destroy(current_);
+ this->destroy(current_);
 }

 H const& hash_function() const {

Modified: trunk/boost/unordered/detail/emplace_args.hpp
==============================================================================
--- trunk/boost/unordered/detail/emplace_args.hpp (original)
+++ trunk/boost/unordered/detail/emplace_args.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -39,7 +39,7 @@

#define BOOST_UNORDERED_EMPLACE_LIMIT 10

-#if 0 && !defined(BOOST_NO_RVALUE_REFERENCES) && \
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && \
 !defined(BOOST_NO_VARIADIC_TEMPLATES)
# if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
# elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
@@ -54,13 +54,17 @@
# elif defined(__IBMCPP__)
# elif defined(MSIPL_COMPILE_H)
# elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
- // Visual C++. A version check would be a good idea.
-# define BOOST_UNORDERED_STD_FORWARD_MOVE
# endif
#endif

namespace boost { namespace unordered { namespace detail {

+ ////////////////////////////////////////////////////////////////////////////
+ // emplace_args
+ //
+ // Either forwarding variadic arguments, or storing the arguments in
+ // emplace_args##n
+
#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)

#define BOOST_UNORDERED_EMPLACE_TEMPLATE typename... Args
@@ -162,12 +166,13 @@
 {};

# define BOOST_UNORDERED_RV_REF(T) \
- typename ::boost::unordered::detail::rv_ref<T>::type
+ typename boost::unordered::detail::rv_ref<T>::type
#endif

 ////////////////////////////////////////////////////////////////////////////
+ // Construct from tuple
 //
- // Value Construction
+ // Used for piecewise construction.

#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_) \
 template<typename T> \
@@ -204,6 +209,16 @@
#undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL
#undef BOOST_UNORDERED_GET_TUPLE_ARG

+ ////////////////////////////////////////////////////////////////////////////
+ // SFINAE traits for construction.
+
+ // Decide which construction method to use for a three argument
+ // call. Note that this is difficult to do using overloads because
+ // the arguments are packed into 'emplace_args3'.
+ //
+ // The decision is made on the first argument.
+
+
#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
 template <typename A, typename B, typename A0>
 struct emulation1 {
@@ -216,328 +231,185 @@
 };
#endif

-#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
 template <typename A, typename B, typename A0>
 struct check3_base {
 static choice1::type check(choice1,
 boost::unordered::piecewise_construct_t);
+
+#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
 static choice2::type check(choice2, A const&);
- static choice3::type check(choice3, ...);
- };
-#else
- template <typename A, typename B, typename A0>
- struct check3_base {
- static choice1::type check(choice1,
- boost::unordered::piecewise_construct_t);
- static choice3::type check(choice3, ...);
- };
#endif

- template <typename A, typename B, typename A0>
- struct piecewise3 {
- enum { value =
- sizeof(check3_base<A,B,A0>::check(choose(), make<A0>())) ==
- sizeof(choice1::type) };
- };
+ static choice3::type check(choice3, ...);

- template <typename A, typename B, typename A0>
- struct emulation3 {
- enum { value =
- sizeof(check3_base<A,B,A0>::check(choose(), make<A0>())) ==
- sizeof(choice2::type) };
+ enum { value = sizeof(check(choose(), make<A0>())) };
 };

 template <typename A, typename B, typename A0>
- struct normal3 {
- enum { value =
- sizeof(check3_base<A,B,A0>::check(choose(), make<A0>())) ==
- sizeof(choice3::type) };
+ struct piecewise3 {
+ enum { value = check3_base<A,B,A0>::value == sizeof(choice1::type) };
 };

- template <typename T, typename A0>
- struct pair_construct1 {};
- template <typename T, typename A0>
- struct normal_construct1 { typedef void type; };
-
#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
 template <typename A, typename B, typename A0>
- struct pair_construct1<std::pair<A, B>, A0>
- : enable_if<emulation1<A, B, A0>, void> {};
-
- template <typename A, typename B, typename A0>
- struct normal_construct1<std::pair<A, B>, A0>
- : disable_if<emulation1<A, B, A0>, void> {};
-#endif
-
- template <typename T, typename A0>
- struct piecewise_construct3 {};
- template <typename A, typename B, typename A0>
- struct piecewise_construct3<std::pair<A, B>, A0>
- : enable_if<piecewise3<A, B, A0>, void> {};
-
- template <typename T, typename A0>
- struct pair_construct3 {};
- template <typename A, typename B, typename A0>
- struct pair_construct3<std::pair<A, B>, A0>
- : enable_if<emulation3<A, B, A0>, void> {};
-
- template <typename T, typename A0>
- struct normal_construct3 { typedef void type; };
- template <typename A, typename B, typename A0>
- struct normal_construct3<std::pair<A, B>, A0>
- : enable_if<normal3<A, B, A0>, void> {};
-
- template <typename T>
- struct pair_construct_n {};
- template <typename T>
- struct normal_construct_n { typedef void type; };
+ struct emulation3 {
+ enum { value = check3_base<A,B,A0>::value == sizeof(choice2::type) };
+ };

-#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
- template <typename A, typename B>
- struct pair_construct_n<std::pair<A, B> > { typedef void type; };
- template <typename A, typename B>
- struct normal_construct_n<std::pair<A, B> > {};
#endif

- template <typename T, typename A0>
- inline typename normal_construct1<T, A0>::type
- construct_impl2(void* address, BOOST_FWD_REF(A0) a0)
- {
- new(address) T(
- boost::forward<A0>(a0)
- );
- }
-
#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)

-////////////////////////////////////////////////////////////////////////////////
-// Construct from variadic parameters
-
- template <typename T>
- inline void construct_impl(void* address)
- {
- new(address) T();
- }
-
- template <typename T, typename A0>
- inline typename normal_construct1<T, A0>::type
- construct_impl(void* address, A0&& a0)
- {
- new(address) T(
- boost::forward<A0>(a0)
- );
- }
-
- template <typename T, typename A0>
- inline typename pair_construct1<T, A0>::type
- construct_impl(void* address, A0&& a0)
- {
- new((void*)(&static_cast<T*>(address)->first))
- typename T::first_type(
- boost::forward<A0>(a0));
- new((void*)(&static_cast<T*>(address)->second))
- typename T::second_type();
- }
+ ////////////////////////////////////////////////////////////////////////////
+ // Construct from variadic parameters

- template <typename T, typename A0, typename A1>
- inline void construct_impl(void* address, A0&& a0, A1&& a1)
+ template <typename T, typename... Args>
+ inline void construct_impl(T* address, Args&&... args)
 {
- new(address) T(
- boost::forward<A0>(a0),
- boost::forward<A1>(a1));
+ new((void*) address) T(std::forward<Args>(args)...);
 }

- template <typename T, typename A0, typename A1, typename A2>
- inline typename piecewise_construct3<T, A0>::type
- construct_impl(void* address, A0&&, A1&& a1, A2&& a2)
+ template <typename A, typename B, typename A0, typename A1, typename A2>
+ inline typename enable_if<piecewise3<A, B, A0>, void>::type
+ construct_impl(std::pair<A, B>* address, A0&&, A1&& a1, A2&& a2)
 {
 construct_from_tuple(
- boost::addressof(static_cast<T*>(address)->first), a1);
+ boost::addressof(address->first), a1);
 construct_from_tuple(
- boost::addressof(static_cast<T*>(address)->second), a2);
+ boost::addressof(address->second), a2);
 }

- template <typename T, typename A0, typename A1, typename A2>
- inline typename pair_construct3<T, A0>::type
- construct_impl(void* address, A0&& a0, A1&& a1, A2&& a2)
- {
- new((void*)(&static_cast<T*>(address)->first))
- typename T::first_type(
- boost::forward<A0>(a0));
- new((void*)(&static_cast<T*>(address)->second))
- typename T::second_type(
- boost::forward<A1>(a1),
- boost::forward<A2>(a2));
- }
+#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)

- template <typename T, typename A0, typename A1, typename A2>
- inline typename normal_construct3<T, A0>::type
- construct_impl(void* address, A0&& a0, A1&& a1, A2&& a2)
+ template <typename A, typename B, typename A0>
+ inline typename enable_if<emulation1<A, B, A0>, void>::type
+ construct_impl(std::pair<A, B>* address, A0&& a0)
 {
- new(address) T(
- boost::forward<A0>(a0),
- boost::forward<A1>(a1),
- boost::forward<A2>(a2));
- }
+ new((void*) boost::addressof(address->first)) A(std::forward<A0>(a0));
+ new((void*) boost::addressof(address->second)) B();
+ }

- template <typename T, typename A0, typename A1, typename A2, typename A3,
- typename... Args>
- inline typename normal_construct_n<T>::type
- construct_impl(void* address, A0&& a0, A1&& a1, A2&& a2,
- A3&& a3, Args&&... args)
+ template <typename A, typename B, typename A0, typename A1, typename A2>
+ inline typename enable_if<emulation3<A, B, A0>, void>::type
+ construct_impl(T* address, A0&& a0, A1&& a1, A2&& a2)
 {
- new(address) T(
- std::forward<A0>(a0),
+ new((void*) boost::addressof(address->first)) A(std::forward<A0>(a0));
+ new((void*) boost::addressof(address->second)) B(
 std::forward<A1>(a1),
- std::forward<A2>(a2),
- std::forward<A3>(a3),
- std::forward<Args>(args)...);
+ std::forward<A2>(a2));
 }

- template <typename T, typename A0, typename A1, typename A2, typename A3,
+ template <typename A, typename B,
+ typename A0, typename A1, typename A2, typename A3,
 typename... Args>
- inline typename pair_construct_n<T>::type
- construct_impl(void* address, A0&& a0, A1&& a1, A2&& a2,
- A3&& a3, Args&&... args)
+ inline void construct_impl(std::pair<A, B>* address,
+ A0&& a0, A1&& a1, A2&& a2, A3&& a3, Args&&... args)
 {
- new((void*)(&static_cast<T*>(address)->first))
- typename T::first_type(
- std::forward<A0>(a0));
- new((void*)(&static_cast<T*>(address)->second))
- typename T::second_type(
+ new((void*) boost::addressof(address->first)) A(std::forward<A0>(a0));
+
+ new((void*) boost::addressof(address->second)) B(
 std::forward<A1>(a1),
 std::forward<A2>(a2),
 std::forward<A3>(a3),
 std::forward<Args>(args)...);
 }

-#else
+#endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
+#else // BOOST_UNORDERED_STD_FORWARD_MOVE

////////////////////////////////////////////////////////////////////////////////
-// Construct with emplace_args
-
- template <typename T, typename A0>
- inline typename normal_construct1<T, A0>::type
- construct_impl(void* address,
- ::boost::unordered::detail::emplace_args1<A0> const& args)
- {
- new(address) T(
- boost::forward<A0>(args.a0)
- );
- }
+// Construct from emplace_args

- template <typename T, typename A0>
- inline typename pair_construct1<T, A0>::type
- construct_impl(void* address, A0 const& a0)
- {
- new((void*)(&static_cast<T*>(address)->first))
- typename T::first_type(
- boost::forward<A0>(a0));
- new((void*)(&static_cast<T*>(address)->second))
- typename T::second_type();
+#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _) \
+ template < \
+ typename T, \
+ BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A) \
+ > \
+ inline void construct_impl(T* address, \
+ boost::unordered::detail::BOOST_PP_CAT(emplace_args,num_params) < \
+ BOOST_PP_ENUM_PARAMS_Z(z, num_params, A) \
+ > const& args) \
+ { \
+ new((void*) address) T( \
+ BOOST_PP_ENUM_##z(num_params, BOOST_UNORDERED_CALL_FORWARD, \
+ args.a)); \
 }

- template <typename T, typename A0>
- inline typename pair_construct1<T, A0>::type
- construct_impl(void* address,
- ::boost::unordered::detail::emplace_args1<A0> const& args)
- {
- new((void*)(&static_cast<T*>(address)->first))
- typename T::first_type(
- boost::forward<A0>(args.a0));
- new((void*)(&static_cast<T*>(address)->second))
- typename T::second_type();
- }
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+ BOOST_UNORDERED_CONSTRUCT_IMPL, _)

- template <typename T, typename A0, typename A1>
- inline void construct_impl(void* address,
- ::boost::unordered::detail::emplace_args2<A0, A1> const& args)
- {
- new(address) T(
- boost::forward<A0>(args.a0),
- boost::forward<A1>(args.a1));
- }
+#undef BOOST_UNORDERED_CONSTRUCT_IMPL

- template <typename T, typename A0, typename A1, typename A2>
- inline typename piecewise_construct3<T, A0>::type
- construct_impl(void* address,
- ::boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
+ template <typename A, typename B, typename A0, typename A1, typename A2>
+ inline typename enable_if<piecewise3<A, B, A0>, void>::type
+ construct_impl(std::pair<A, B>* address,
+ boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
 {
 construct_from_tuple(
- boost::addressof(static_cast<T*>(address)->first), args.a1);
+ boost::addressof(address->first), args.a1);
 construct_from_tuple(
- boost::addressof(static_cast<T*>(address)->second), args.a2);
+ boost::addressof(address->second), args.a2);
 }

- template <typename T, typename A0, typename A1, typename A2>
- inline typename pair_construct3<T, A0>::type
- construct_impl(void* address,
- ::boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
+#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
+
+ template <typename A, typename B, typename A0>
+ inline typename enable_if<emulation1<A, B, A0>, void>::type
+ construct_impl(std::pair<A, B>* address,
+ boost::unordered::detail::emplace_args1<A0> const& args)
 {
- new((void*)(&static_cast<T*>(address)->first))
- typename T::first_type(
+ new((void*) boost::addressof(address->first)) A(
 boost::forward<A0>(args.a0));
- new((void*)(&static_cast<T*>(address)->second))
- typename T::second_type(
- boost::forward<A1>(args.a1),
- boost::forward<A2>(args.a2));
+ new((void*) boost::addressof(address->second)) B();
 }

- template <typename T, typename A0, typename A1, typename A2>
- inline typename normal_construct3<T, A0>::type
- construct_impl(void* address,
- ::boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
+ template <typename A, typename B, typename A0, typename A1, typename A2>
+ inline typename enable_if<emulation3<A, B, A0>, void>::type
+ construct_impl(std::pair<A, B>* address,
+ boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
 {
- new(address) T(
- boost::forward<A0>(args.a0),
+ new((void*) boost::addressof(address->first)) A(
+ boost::forward<A0>(args.a0));
+ new((void*) boost::addressof(address->second)) B(
 boost::forward<A1>(args.a1),
 boost::forward<A2>(args.a2));
 }

-#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _) \
- template < \
- typename T, \
- BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A) \
- > \
- inline typename normal_construct_n<T>::type \
- construct_impl(void* address, \
- ::boost::unordered::detail::BOOST_PP_CAT(emplace_args,num_params) < \
- BOOST_PP_ENUM_PARAMS_Z(z, num_params, A) \
- > const& args) \
- { \
- new(address) T( \
- BOOST_PP_ENUM_##z(num_params, BOOST_UNORDERED_CALL_FORWARD, \
- args.a)); \
- }
-
- BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
- BOOST_UNORDERED_CONSTRUCT_IMPL, _)
-
#define BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL(z, num_params, _) \
- template <typename T, \
+ template <typename A, typename B, \
 BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A) \
> \
- inline typename pair_construct_n<T>::type \
- construct_impl(void* address, \
- ::boost::unordered::detail::BOOST_PP_CAT(emplace_args,num_params) < \
+ inline void construct_impl(std::pair<A, B>* address, \
+ boost::unordered::detail::BOOST_PP_CAT(emplace_args,num_params) < \
 BOOST_PP_ENUM_PARAMS_Z(z, num_params, A) \
> const& args) \
 { \
- new((void*)(&static_cast<T*>(address)->first)) \
- typename T::first_type( \
+ new((void*) boost::addressof(address->first)) A( \
 boost::forward<A0>(args.a0)); \
- new((void*)(&static_cast<T*>(address)->second)) \
- typename T::second_type( \
+ new((void*) boost::addressof(address->second)) B( \
 BOOST_PP_ENUM_SHIFTED_##z(num_params, \
 BOOST_UNORDERED_CALL_FORWARD, args.a)); \
 }

+ BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL(1, 2, _)
 BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
 BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL, _)

-#undef BOOST_UNORDERED_CONSTRUCT_IMPL
#undef BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL
-#endif
+
+#endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
+#endif // BOOST_UNORDERED_STD_FORWARD_MOVE
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Construct without using the emplace args mechanism.
+
+ template <typename T, typename A0>
+ inline void construct_impl2(T* address, BOOST_FWD_REF(A0) a0)
+ {
+ new((void*) address) T(
+ boost::forward<A0>(a0)
+ );
+ }

}}}

Modified: trunk/boost/unordered/detail/equivalent.hpp
==============================================================================
--- trunk/boost/unordered/detail/equivalent.hpp (original)
+++ trunk/boost/unordered/detail/equivalent.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -23,7 +23,7 @@

 template <typename VoidPointer, typename T>
 struct grouped_node :
- ::boost::unordered::detail::value_base<T>
+ boost::unordered::detail::value_base<T>
 {
 typedef VoidPointer link_pointer;

@@ -45,10 +45,10 @@

 template <typename T>
 struct grouped_ptr_node :
- ::boost::unordered::detail::value_base<T>,
- ::boost::unordered::detail::ptr_bucket
+ boost::unordered::detail::value_base<T>,
+ boost::unordered::detail::ptr_bucket
 {
- typedef ::boost::unordered::detail::ptr_bucket bucket_base;
+ typedef boost::unordered::detail::ptr_bucket bucket_base;
 typedef ptr_bucket* link_pointer;

 link_pointer group_prev_;
@@ -72,37 +72,37 @@
 template <typename A, typename T, typename VoidPointer, typename NodePtr, typename BucketPtr>
 struct pick_grouped_node2
 {
- typedef ::boost::unordered::detail::grouped_node<VoidPointer, T> node;
+ typedef boost::unordered::detail::grouped_node<VoidPointer, T> node;

- typedef typename ::boost::unordered::detail::allocator_traits<
- typename ::boost::unordered::detail::rebind_wrap<A, node>::type
+ typedef typename boost::unordered::detail::allocator_traits<
+ typename boost::unordered::detail::rebind_wrap<A, node>::type
>::pointer node_pointer;

- typedef ::boost::unordered::detail::bucket<node_pointer> bucket;
+ typedef boost::unordered::detail::bucket<node_pointer> bucket;
 typedef VoidPointer link_pointer;
 };

 template <typename A, typename T>
 struct pick_grouped_node2<A, T, void*,
- ::boost::unordered::detail::grouped_ptr_node<T>*,
- ::boost::unordered::detail::ptr_bucket*>
+ boost::unordered::detail::grouped_ptr_node<T>*,
+ boost::unordered::detail::ptr_bucket*>
 {
- typedef ::boost::unordered::detail::grouped_ptr_node<T> node;
- typedef ::boost::unordered::detail::ptr_bucket bucket;
+ typedef boost::unordered::detail::grouped_ptr_node<T> node;
+ typedef boost::unordered::detail::ptr_bucket bucket;
 typedef bucket* link_pointer;
 };

 template <typename A, typename T>
 struct pick_grouped_node
 {
- typedef ::boost::unordered::detail::allocator_traits<
- typename ::boost::unordered::detail::rebind_wrap<A,
- ::boost::unordered::detail::grouped_ptr_node<T> >::type
+ typedef boost::unordered::detail::allocator_traits<
+ typename boost::unordered::detail::rebind_wrap<A,
+ boost::unordered::detail::grouped_ptr_node<T> >::type
> tentative_node_traits;

- typedef ::boost::unordered::detail::allocator_traits<
- typename ::boost::unordered::detail::rebind_wrap<A,
- ::boost::unordered::detail::ptr_bucket >::type
+ typedef boost::unordered::detail::allocator_traits<
+ typename boost::unordered::detail::rebind_wrap<A,
+ boost::unordered::detail::ptr_bucket >::type
> tentative_bucket_traits;

 typedef pick_grouped_node2<A, T,
@@ -124,17 +124,17 @@
 typedef H hasher;
 typedef P key_equal;

- typedef ::boost::unordered::detail::allocator_traits<A> traits;
+ typedef boost::unordered::detail::allocator_traits<A> traits;
 typedef typename traits::value_type value_type;
 typedef typename traits::void_pointer void_pointer;
 typedef value_type key_type;

- typedef typename ::boost::unordered::detail::pick_grouped_node<A, value_type>::node node;
- typedef typename ::boost::unordered::detail::pick_grouped_node<A, value_type>::bucket bucket;
- typedef typename ::boost::unordered::detail::pick_grouped_node<A, value_type>::link_pointer link_pointer;
- typedef ::boost::unordered::detail::grouped_table_impl<types> table;
+ typedef typename boost::unordered::detail::pick_grouped_node<A, value_type>::node node;
+ typedef typename boost::unordered::detail::pick_grouped_node<A, value_type>::bucket bucket;
+ typedef typename boost::unordered::detail::pick_grouped_node<A, value_type>::link_pointer link_pointer;
+ typedef boost::unordered::detail::grouped_table_impl<types> table;

- typedef ::boost::unordered::detail::set_extractor<value_type> extractor;
+ typedef boost::unordered::detail::set_extractor<value_type> extractor;
 };

 template <typename A, typename K, typename H, typename P>
@@ -147,22 +147,22 @@
 typedef P key_equal;
 typedef K key_type;

- typedef ::boost::unordered::detail::allocator_traits<A> traits;
+ typedef boost::unordered::detail::allocator_traits<A> traits;
 typedef typename traits::value_type value_type;
 typedef typename traits::void_pointer void_pointer;

- typedef typename ::boost::unordered::detail::pick_grouped_node<A, value_type>::node node;
- typedef typename ::boost::unordered::detail::pick_grouped_node<A, value_type>::bucket bucket;
- typedef typename ::boost::unordered::detail::pick_grouped_node<A, value_type>::link_pointer link_pointer;
- typedef ::boost::unordered::detail::grouped_table_impl<types> table;
+ typedef typename boost::unordered::detail::pick_grouped_node<A, value_type>::node node;
+ typedef typename boost::unordered::detail::pick_grouped_node<A, value_type>::bucket bucket;
+ typedef typename boost::unordered::detail::pick_grouped_node<A, value_type>::link_pointer link_pointer;
+ typedef boost::unordered::detail::grouped_table_impl<types> table;

- typedef ::boost::unordered::detail::map_extractor<key_type, value_type> extractor;
+ typedef boost::unordered::detail::map_extractor<key_type, value_type> extractor;
 };

 template <typename Types>
- struct grouped_table_impl : ::boost::unordered::detail::table<Types>
+ struct grouped_table_impl : boost::unordered::detail::table<Types>
 {
- typedef ::boost::unordered::detail::table<Types> table;
+ typedef boost::unordered::detail::table<Types> table;
 typedef typename table::value_type value_type;
 typedef typename table::bucket bucket;
 typedef typename table::buckets buckets;
@@ -197,13 +197,13 @@
 {}

 grouped_table_impl(grouped_table_impl& x,
- ::boost::unordered::detail::move_tag m)
+ boost::unordered::detail::move_tag m)
 : table(x, m)
 {}

 grouped_table_impl(grouped_table_impl& x,
 node_allocator const& a,
- ::boost::unordered::detail::move_tag m)
+ boost::unordered::detail::move_tag m)
 : table(x, a, m)
 {}

@@ -441,8 +441,8 @@
 }

#if defined(BOOST_NO_RVALUE_REFERENCES)
- node_pointer emplace(::boost::unordered::detail::emplace_args1<
- ::boost::unordered::detail::please_ignore_this_overload> const&)
+ node_pointer emplace(boost::unordered::detail::emplace_args1<
+ boost::unordered::detail::please_ignore_this_overload> const&)
 {
 BOOST_ASSERT(false);
 return this->begin();
@@ -465,12 +465,12 @@
 // if hash function throws, or inserting > 1 element, basic exception
 // safety. Strong otherwise
 template <class I>
- typename ::boost::unordered::detail::enable_if_forward<I, void>::type
+ typename boost::unordered::detail::enable_if_forward<I, void>::type
 insert_range(I i, I j)
 {
 if(i == j) return;

- std::size_t distance = ::boost::unordered::detail::distance(i, j);
+ std::size_t distance = boost::unordered::detail::distance(i, j);
 if(distance == 1) {
 node_constructor a(this->node_alloc());
 a.construct_node();
@@ -491,7 +491,7 @@
 }

 template <class I>
- typename ::boost::unordered::detail::disable_if_forward<I, void>::type
+ typename boost::unordered::detail::disable_if_forward<I, void>::type
 insert_range(I i, I j)
 {
 node_constructor a(this->node_alloc());
@@ -614,6 +614,7 @@
 previous_pointer prev = static_cast<previous_pointer>(begin->group_prev_);

 if(prev->next_ != static_cast<link_pointer>(begin)) {
+std::cout << "A" << std::endl;
 // The node is at the beginning of a group.

 // Find the previous node pointer:
@@ -625,6 +626,7 @@
 if (end) split_group(end);
 }
 else {
+std::cout << "B" << std::endl;
 node_pointer group1 = split_group(begin);

 if (end) {

Modified: trunk/boost/unordered/detail/extract_key.hpp
==============================================================================
--- trunk/boost/unordered/detail/extract_key.hpp (original)
+++ trunk/boost/unordered/detail/extract_key.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -93,7 +93,7 @@
 struct map_extractor
 {
 typedef ValueType value_type;
- typedef typename ::boost::remove_const<Key>::type key_type;
+ typedef typename boost::remove_const<Key>::type key_type;

 static key_type const& extract(value_type const& v)
 {

Modified: trunk/boost/unordered/detail/table.hpp
==============================================================================
--- trunk/boost/unordered/detail/table.hpp (original)
+++ trunk/boost/unordered/detail/table.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -32,13 +32,13 @@

 template <typename NodePointer, typename Value>
 struct l_iterator
- : public ::boost::iterator<
+ : public boost::iterator<
 std::forward_iterator_tag, Value, std::ptrdiff_t,
 NodePointer, Value&>
 {
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
 template <typename ConstNodePointer, typename NodePointer2, typename Value2>
- friend struct ::boost::unordered::iterator_detail::cl_iterator;
+ friend struct boost::unordered::iterator_detail::cl_iterator;
 private:
#endif
 typedef NodePointer node_pointer;
@@ -85,11 +85,11 @@

 template <typename ConstNodePointer, typename NodePointer, typename Value>
 struct cl_iterator
- : public ::boost::iterator<
+ : public boost::iterator<
 std::forward_iterator_tag, Value, std::ptrdiff_t,
 ConstNodePointer, Value const&>
 {
- friend struct ::boost::unordered::iterator_detail::l_iterator
+ friend struct boost::unordered::iterator_detail::l_iterator
 <NodePointer, Value>;
 private:

@@ -142,13 +142,13 @@

 template <typename NodePointer, typename Value>
 struct iterator
- : public ::boost::iterator<
+ : public boost::iterator<
 std::forward_iterator_tag, Value, std::ptrdiff_t,
 NodePointer, Value&>
 {
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
 template <typename ConstNodePointer, typename NodePointer2, typename Value2>
- friend struct ::boost::unordered::iterator_detail::c_iterator;
+ friend struct boost::unordered::iterator_detail::c_iterator;
 private:
#endif
 typedef NodePointer node_pointer;
@@ -187,21 +187,21 @@

 template <typename ConstNodePointer, typename NodePointer, typename Value>
 struct c_iterator
- : public ::boost::iterator<
+ : public boost::iterator<
 std::forward_iterator_tag, Value, std::ptrdiff_t,
 ConstNodePointer, Value const&>
 {
- friend struct ::boost::unordered::iterator_detail::iterator<NodePointer, Value>;
+ friend struct boost::unordered::iterator_detail::iterator<NodePointer, Value>;

#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
 template <typename K, typename T, typename H, typename P, typename A>
- friend class ::boost::unordered::unordered_map;
+ friend class boost::unordered::unordered_map;
 template <typename K, typename T, typename H, typename P, typename A>
- friend class ::boost::unordered::unordered_multimap;
+ friend class boost::unordered::unordered_multimap;
 template <typename T, typename H, typename P, typename A>
- friend class ::boost::unordered::unordered_set;
+ friend class boost::unordered::unordered_set;
 template <typename T, typename H, typename P, typename A>
- friend class ::boost::unordered::unordered_multiset;
+ friend class boost::unordered::unordered_multiset;

 private:
#endif
@@ -263,9 +263,9 @@
 {
 typedef ValueType value_type;

- typename ::boost::aligned_storage<
+ typename boost::aligned_storage<
 sizeof(value_type),
- ::boost::alignment_of<value_type>::value>::type data_;
+ boost::alignment_of<value_type>::value>::type data_;

 void* address() {
 return this;
@@ -286,11 +286,11 @@

 template <typename Types>
 struct table :
- ::boost::unordered::detail::buckets<
+ boost::unordered::detail::buckets<
 typename Types::allocator,
 typename Types::bucket,
 typename Types::node>,
- ::boost::unordered::detail::functions<
+ boost::unordered::detail::functions<
 typename Types::hasher,
 typename Types::key_equal>
 {
@@ -306,11 +306,11 @@
 typedef typename Types::table table_impl;
 typedef typename Types::link_pointer link_pointer;

- typedef ::boost::unordered::detail::functions<
+ typedef boost::unordered::detail::functions<
 typename Types::hasher,
 typename Types::key_equal> functions;

- typedef ::boost::unordered::detail::buckets<
+ typedef boost::unordered::detail::buckets<
 typename Types::allocator,
 typename Types::bucket,
 typename Types::node> buckets;
@@ -320,10 +320,10 @@
 typedef typename buckets::node_pointer node_pointer;
 typedef typename buckets::const_node_pointer const_node_pointer;

- typedef ::boost::unordered::iterator_detail::iterator<node_pointer, value_type> iterator;
- typedef ::boost::unordered::iterator_detail::c_iterator<const_node_pointer, node_pointer, value_type> c_iterator;
- typedef ::boost::unordered::iterator_detail::l_iterator<node_pointer, value_type> l_iterator;
- typedef ::boost::unordered::iterator_detail::cl_iterator<const_node_pointer, node_pointer, value_type> cl_iterator;
+ typedef boost::unordered::iterator_detail::iterator<node_pointer, value_type> iterator;
+ typedef boost::unordered::iterator_detail::c_iterator<const_node_pointer, node_pointer, value_type> c_iterator;
+ typedef boost::unordered::iterator_detail::l_iterator<node_pointer, value_type> l_iterator;
+ typedef boost::unordered::iterator_detail::cl_iterator<const_node_pointer, node_pointer, value_type> cl_iterator;

 // Members

@@ -338,7 +338,7 @@
 using namespace std;

 // size < mlf_ * count
- return ::boost::unordered::detail::double_to_size_t(ceil(
+ return boost::unordered::detail::double_to_size_t(ceil(
 static_cast<double>(this->mlf_) *
 static_cast<double>(this->max_bucket_count())
 )) - 1;
@@ -350,7 +350,7 @@

 // From 6.3.1/13:
 // Only resize when size >= mlf_ * count
- return ::boost::unordered::detail::double_to_size_t(ceil(
+ return boost::unordered::detail::double_to_size_t(ceil(
 static_cast<double>(this->mlf_) *
 static_cast<double>(this->bucket_count_)
 ));
@@ -377,8 +377,8 @@
 // Or from rehash post-condition:
 // count > size / mlf_

- return ::boost::unordered::detail::next_prime(
- ::boost::unordered::detail::double_to_size_t(floor(
+ return boost::unordered::detail::next_prime(
+ boost::unordered::detail::double_to_size_t(floor(
 static_cast<double>(size) /
 static_cast<double>(mlf_))) + 1);
 }
@@ -390,7 +390,7 @@
 hasher const& hf,
 key_equal const& eq,
 node_allocator const& a) :
- buckets(a, ::boost::unordered::detail::next_prime(num_buckets)),
+ buckets(a, boost::unordered::detail::next_prime(num_buckets)),
 functions(hf, eq),
 mlf_(1.0f),
 max_load_(0)
@@ -409,7 +409,7 @@
 }

 // TODO: Why calculate_max_load?
- table(table& x, ::boost::unordered::detail::move_tag m) :
+ table(table& x, boost::unordered::detail::move_tag m) :
 buckets(x, m),
 functions(x),
 mlf_(x.mlf_),
@@ -419,14 +419,14 @@
 // TODO: Why not calculate_max_load?
 // TODO: Why do I use x's bucket count?
 table(table& x, node_allocator const& a,
- ::boost::unordered::detail::move_tag m) :
+ boost::unordered::detail::move_tag m) :
 buckets(a, x.bucket_count_),
 functions(x),
 mlf_(x.mlf_),
 max_load_(x.max_load_)
 {
 if(a == x.node_alloc()) {
- this->buckets::swap(x, boost::unordered::detail::false_type());
+ this->buckets::swap(x, false_type());
 }
 else if(x.size_) {
 // Use a temporary table because move_buckets_to leaves the
@@ -450,18 +450,18 @@
 void assign(table const& x)
 {
 assign(x,
- ::boost::unordered::detail::integral_constant<bool,
+ boost::unordered::detail::integral_constant<bool,
 allocator_traits<node_allocator>::
 propagate_on_container_copy_assignment::value>());
 }

- void assign(table const& x, boost::unordered::detail::false_type)
+ void assign(table const& x, false_type)
 {
 table tmp(x, this->node_alloc());
- this->swap(tmp, boost::unordered::detail::false_type());
+ this->swap(tmp, false_type());
 }

- void assign(table const& x, boost::unordered::detail::true_type)
+ void assign(table const& x, true_type)
 {
 table tmp(x, x.node_alloc());
 // Need to delete before setting the allocator so that buckets
@@ -469,25 +469,25 @@
 if(this->buckets_) this->delete_buckets();
 // TODO: Can allocator assignment throw?
 this->allocators_.assign(x.allocators_);
- this->swap(tmp, boost::unordered::detail::false_type());
+ this->swap(tmp, false_type());
 }

 void move_assign(table& x)
 {
 move_assign(x,
- ::boost::unordered::detail::integral_constant<bool,
+ boost::unordered::detail::integral_constant<bool,
 allocator_traits<node_allocator>::
 propagate_on_container_move_assignment::value>());
 }

- void move_assign(table& x, boost::unordered::detail::true_type)
+ void move_assign(table& x, true_type)
 {
 if(this->buckets_) this->delete_buckets();
 this->allocators_.move_assign(x.allocators_);
 move_assign_no_alloc(x);
 }

- void move_assign(table& x, boost::unordered::detail::false_type)
+ void move_assign(table& x, false_type)
 {
 if(this->node_alloc() == x.node_alloc()) {
 if(this->buckets_) this->delete_buckets();
@@ -647,7 +647,7 @@
 }
 else {
 min_buckets = next_prime((std::max)(min_buckets,
- ::boost::unordered::detail::double_to_size_t(floor(
+ boost::unordered::detail::double_to_size_t(floor(
 static_cast<double>(this->size_) /
 static_cast<double>(mlf_))) + 1));

Modified: trunk/boost/unordered/detail/unique.hpp
==============================================================================
--- trunk/boost/unordered/detail/unique.hpp (original)
+++ trunk/boost/unordered/detail/unique.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -25,7 +25,7 @@

 template <typename VoidPointer, typename T>
 struct node :
- ::boost::unordered::detail::value_base<T>
+ boost::unordered::detail::value_base<T>
 {
 typedef VoidPointer link_pointer;

@@ -44,10 +44,10 @@

 template <typename T>
 struct ptr_node :
- ::boost::unordered::detail::value_base<T>,
- ::boost::unordered::detail::ptr_bucket
+ boost::unordered::detail::value_base<T>,
+ boost::unordered::detail::ptr_bucket
 {
- typedef ::boost::unordered::detail::ptr_bucket bucket_base;
+ typedef boost::unordered::detail::ptr_bucket bucket_base;
 typedef ptr_bucket* link_pointer;

 std::size_t hash_;
@@ -68,37 +68,37 @@
 template <typename A, typename T, typename VoidPointer, typename NodePtr, typename BucketPtr>
 struct pick_node2
 {
- typedef ::boost::unordered::detail::node<VoidPointer, T> node;
+ typedef boost::unordered::detail::node<VoidPointer, T> node;

- typedef typename ::boost::unordered::detail::allocator_traits<
- typename ::boost::unordered::detail::rebind_wrap<A, node>::type
+ typedef typename boost::unordered::detail::allocator_traits<
+ typename boost::unordered::detail::rebind_wrap<A, node>::type
>::pointer node_pointer;

- typedef ::boost::unordered::detail::bucket<node_pointer> bucket;
+ typedef boost::unordered::detail::bucket<node_pointer> bucket;
 typedef VoidPointer link_pointer;
 };

 template <typename A, typename T>
 struct pick_node2<A, T, void*,
- ::boost::unordered::detail::ptr_node<T>*,
- ::boost::unordered::detail::ptr_bucket*>
+ boost::unordered::detail::ptr_node<T>*,
+ boost::unordered::detail::ptr_bucket*>
 {
- typedef ::boost::unordered::detail::ptr_node<T> node;
- typedef ::boost::unordered::detail::ptr_bucket bucket;
+ typedef boost::unordered::detail::ptr_node<T> node;
+ typedef boost::unordered::detail::ptr_bucket bucket;
 typedef bucket* link_pointer;
 };

 template <typename A, typename T>
 struct pick_node
 {
- typedef ::boost::unordered::detail::allocator_traits<
- typename ::boost::unordered::detail::rebind_wrap<A,
- ::boost::unordered::detail::ptr_node<T> >::type
+ typedef boost::unordered::detail::allocator_traits<
+ typename boost::unordered::detail::rebind_wrap<A,
+ boost::unordered::detail::ptr_node<T> >::type
> tentative_node_traits;

- typedef ::boost::unordered::detail::allocator_traits<
- typename ::boost::unordered::detail::rebind_wrap<A,
- ::boost::unordered::detail::ptr_bucket >::type
+ typedef boost::unordered::detail::allocator_traits<
+ typename boost::unordered::detail::rebind_wrap<A,
+ boost::unordered::detail::ptr_bucket >::type
> tentative_bucket_traits;

 typedef pick_node2<A, T,
@@ -120,17 +120,17 @@
 typedef H hasher;
 typedef P key_equal;

- typedef ::boost::unordered::detail::allocator_traits<A> traits;
+ typedef boost::unordered::detail::allocator_traits<A> traits;
 typedef typename traits::value_type value_type;
 typedef typename traits::void_pointer void_pointer;
 typedef value_type key_type;

- typedef typename ::boost::unordered::detail::pick_node<A, value_type>::node node;
- typedef typename ::boost::unordered::detail::pick_node<A, value_type>::bucket bucket;
- typedef typename ::boost::unordered::detail::pick_node<A, value_type>::link_pointer link_pointer;
- typedef ::boost::unordered::detail::table_impl<types> table;
+ typedef typename boost::unordered::detail::pick_node<A, value_type>::node node;
+ typedef typename boost::unordered::detail::pick_node<A, value_type>::bucket bucket;
+ typedef typename boost::unordered::detail::pick_node<A, value_type>::link_pointer link_pointer;
+ typedef boost::unordered::detail::table_impl<types> table;

- typedef ::boost::unordered::detail::set_extractor<value_type> extractor;
+ typedef boost::unordered::detail::set_extractor<value_type> extractor;
 };

 template <typename A, typename K, typename H, typename P>
@@ -143,22 +143,22 @@
 typedef P key_equal;
 typedef K key_type;

- typedef ::boost::unordered::detail::allocator_traits<A> traits;
+ typedef boost::unordered::detail::allocator_traits<A> traits;
 typedef typename traits::value_type value_type;
 typedef typename traits::void_pointer void_pointer;

- typedef typename ::boost::unordered::detail::pick_node<A, value_type>::node node;
- typedef typename ::boost::unordered::detail::pick_node<A, value_type>::bucket bucket;
- typedef typename ::boost::unordered::detail::pick_node<A, value_type>::link_pointer link_pointer;
- typedef ::boost::unordered::detail::table_impl<types> table;
+ typedef typename boost::unordered::detail::pick_node<A, value_type>::node node;
+ typedef typename boost::unordered::detail::pick_node<A, value_type>::bucket bucket;
+ typedef typename boost::unordered::detail::pick_node<A, value_type>::link_pointer link_pointer;
+ typedef boost::unordered::detail::table_impl<types> table;

- typedef ::boost::unordered::detail::map_extractor<key_type, value_type> extractor;
+ typedef boost::unordered::detail::map_extractor<key_type, value_type> extractor;
 };

 template <typename Types>
- struct table_impl : ::boost::unordered::detail::table<Types>
+ struct table_impl : boost::unordered::detail::table<Types>
 {
- typedef ::boost::unordered::detail::table<Types> table;
+ typedef boost::unordered::detail::table<Types> table;
 typedef typename table::value_type value_type;
 typedef typename table::bucket bucket;
 typedef typename table::buckets buckets;
@@ -195,13 +195,13 @@
 {}

 table_impl(table_impl& x,
- ::boost::unordered::detail::move_tag m)
+ boost::unordered::detail::move_tag m)
 : table(x, m)
 {}

 table_impl(table_impl& x,
 node_allocator const& a,
- ::boost::unordered::detail::move_tag m)
+ boost::unordered::detail::move_tag m)
 : table(x, a, m)
 {}

@@ -248,7 +248,7 @@
 if (it) return it->value();
 }

- ::boost::throw_exception(
+ boost::throw_exception(
 std::out_of_range("Unable to find key in unordered_map."));
 }

@@ -349,8 +349,8 @@
 }

#if defined(BOOST_NO_RVALUE_REFERENCES)
- emplace_return emplace(::boost::unordered::detail::emplace_args1<
- ::boost::unordered::detail::please_ignore_this_overload> const&)
+ emplace_return emplace(boost::unordered::detail::emplace_args1<
+ boost::unordered::detail::please_ignore_this_overload> const&)
 {
 BOOST_ASSERT(false);
 return emplace_return(this->begin(), false);
@@ -472,7 +472,7 @@
 a.construct_node();
 a.construct_value2(*i);
 this->reserve_for_insert(this->size_ +
- ::boost::unordered::detail::insert_size(i, j));
+ boost::unordered::detail::insert_size(i, j));
 this->add_node(a, hash);
 }

@@ -490,7 +490,7 @@

 if(this->size_ + 1 >= this->max_load_)
 this->reserve_for_insert(this->size_ +
- ::boost::unordered::detail::insert_size(i, j));
+ boost::unordered::detail::insert_size(i, j));

 // Nothing after this point can throw.
 this->add_node(a, hash);

Modified: trunk/boost/unordered/detail/util.hpp
==============================================================================
--- trunk/boost/unordered/detail/util.hpp (original)
+++ trunk/boost/unordered/detail/util.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -33,22 +33,22 @@

 template <typename I>
 struct is_forward :
- ::boost::is_convertible<
- typename ::boost::iterator_traversal::type,
- ::boost::forward_traversal_tag>
+ boost::is_convertible<
+ typename boost::iterator_traversal::type,
+ boost::forward_traversal_tag>
 {};

 template <typename I, typename ReturnType>
 struct enable_if_forward :
- ::boost::enable_if_c<
- ::boost::unordered::detail::is_forward::value,
+ boost::enable_if_c<
+ boost::unordered::detail::is_forward::value,
 ReturnType>
 {};

 template <typename I, typename ReturnType>
 struct disable_if_forward :
- ::boost::disable_if_c<
- ::boost::unordered::detail::is_forward::value,
+ boost::disable_if_c<
+ boost::unordered::detail::is_forward::value,
 ReturnType>
 {};

@@ -135,7 +135,7 @@

 template <class I>
 inline typename
- ::boost::unordered::detail::enable_if_forward<I, std::size_t>::type
+ boost::unordered::detail::enable_if_forward<I, std::size_t>::type
 insert_size(I i, I j)
 {
 return std::distance(i, j);
@@ -143,7 +143,7 @@

 template <class I>
 inline typename
- ::boost::unordered::detail::disable_if_forward<I, std::size_t>::type
+ boost::unordered::detail::disable_if_forward<I, std::size_t>::type
 insert_size(I, I)
 {
 return 1;
@@ -151,11 +151,11 @@

 template <class I>
 inline std::size_t initial_size(I i, I j,
- std::size_t num_buckets = ::boost::unordered::detail::default_bucket_count)
+ std::size_t num_buckets = boost::unordered::detail::default_bucket_count)
 {
 // TODO: Why +1?
 return (std::max)(
- ::boost::unordered::detail::insert_size(i, j) + 1,
+ boost::unordered::detail::insert_size(i, j) + 1,
 num_buckets);
 }

Modified: trunk/boost/unordered/unordered_map.hpp
==============================================================================
--- trunk/boost/unordered/unordered_map.hpp (original)
+++ trunk/boost/unordered/unordered_map.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -54,14 +54,14 @@

 private:

- typedef typename ::boost::unordered::detail::rebind_wrap<
+ typedef typename boost::unordered::detail::rebind_wrap<
 allocator_type, value_type>::type
 value_allocator;

- typedef ::boost::unordered::detail::allocator_traits<value_allocator>
+ typedef boost::unordered::detail::allocator_traits<value_allocator>
 allocator_traits;

- typedef ::boost::unordered::detail::map<value_allocator, K, H, P>
+ typedef boost::unordered::detail::map<value_allocator, K, H, P>
 types;
 typedef typename types::table table;

@@ -90,7 +90,7 @@
 // constructors

 explicit unordered_map(
- size_type = ::boost::unordered::detail::default_bucket_count,
+ size_type = boost::unordered::detail::default_bucket_count,
 const hasher& = hasher(),
 const key_equal& = key_equal(),
 const allocator_type& = allocator_type());
@@ -122,7 +122,7 @@
 unordered_map(unordered_map const&, allocator_type const&);

 unordered_map(BOOST_RV_REF(unordered_map) other)
- : table_(other.table_, ::boost::unordered::detail::move_tag())
+ : table_(other.table_, boost::unordered::detail::move_tag())
 {
 }

@@ -133,7 +133,7 @@
#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
 unordered_map(
 std::initializer_list<value_type>,
- size_type = ::boost::unordered::detail::default_bucket_count,
+ size_type = boost::unordered::detail::default_bucket_count,
 const hasher& = hasher(),
 const key_equal&l = key_equal(),
 const allocator_type& = allocator_type());
@@ -237,7 +237,7 @@
 ) \
 { \
 return table_.emplace( \
- ::boost::unordered::detail::create_emplace_args( \
+ boost::unordered::detail::create_emplace_args( \
 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
 a) \
 )); \
@@ -252,7 +252,7 @@
 ) \
 { \
 return iterator(table_.emplace( \
- ::boost::unordered::detail::create_emplace_args( \
+ boost::unordered::detail::create_emplace_args( \
 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
 a) \
 )).first); \
@@ -445,14 +445,14 @@

 private:

- typedef typename ::boost::unordered::detail::rebind_wrap<
+ typedef typename boost::unordered::detail::rebind_wrap<
 allocator_type, value_type>::type
 value_allocator;

- typedef ::boost::unordered::detail::allocator_traits<value_allocator>
+ typedef boost::unordered::detail::allocator_traits<value_allocator>
 allocator_traits;

- typedef ::boost::unordered::detail::multimap<value_allocator, K, H, P>
+ typedef boost::unordered::detail::multimap<value_allocator, K, H, P>
 types;
 typedef typename types::table table;

@@ -481,7 +481,7 @@
 // constructors

 explicit unordered_multimap(
- size_type = ::boost::unordered::detail::default_bucket_count,
+ size_type = boost::unordered::detail::default_bucket_count,
 const hasher& = hasher(),
 const key_equal& = key_equal(),
 const allocator_type& = allocator_type());
@@ -513,7 +513,7 @@
 unordered_multimap(unordered_multimap const&, allocator_type const&);

 unordered_multimap(BOOST_RV_REF(unordered_multimap) other)
- : table_(other.table_, ::boost::unordered::detail::move_tag())
+ : table_(other.table_, boost::unordered::detail::move_tag())
 {
 }

@@ -524,7 +524,7 @@
#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
 unordered_multimap(
 std::initializer_list<value_type>,
- size_type = ::boost::unordered::detail::default_bucket_count,
+ size_type = boost::unordered::detail::default_bucket_count,
 const hasher& = hasher(),
 const key_equal&l = key_equal(),
 const allocator_type& = allocator_type());
@@ -628,7 +628,7 @@
 ) \
 { \
 return iterator(table_.emplace( \
- ::boost::unordered::detail::create_emplace_args( \
+ boost::unordered::detail::create_emplace_args( \
 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
 a) \
 ))); \
@@ -643,7 +643,7 @@
 ) \
 { \
 return iterator(table_.emplace( \
- ::boost::unordered::detail::create_emplace_args( \
+ boost::unordered::detail::create_emplace_args( \
 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
 a) \
 ))); \
@@ -828,7 +828,7 @@

 template <class K, class T, class H, class P, class A>
 unordered_map<K,T,H,P,A>::unordered_map(allocator_type const& a)
- : table_(::boost::unordered::detail::default_bucket_count,
+ : table_(boost::unordered::detail::default_bucket_count,
 hasher(), key_equal(), a)
 {
 }
@@ -843,7 +843,7 @@
 template <class K, class T, class H, class P, class A>
 template <class InputIt>
 unordered_map<K,T,H,P,A>::unordered_map(InputIt f, InputIt l)
- : table_(::boost::unordered::detail::initial_size(f, l),
+ : table_(boost::unordered::detail::initial_size(f, l),
 hasher(), key_equal(), allocator_type())
 {
 table_.insert_range(f, l);
@@ -856,7 +856,7 @@
 size_type n,
 const hasher &hf,
 const key_equal &eql)
- : table_(::boost::unordered::detail::initial_size(f, l, n),
+ : table_(boost::unordered::detail::initial_size(f, l, n),
 hf, eql, allocator_type())
 {
 table_.insert_range(f, l);
@@ -870,7 +870,7 @@
 const hasher &hf,
 const key_equal &eql,
 const allocator_type &a)
- : table_(::boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
+ : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
 {
 table_.insert_range(f, l);
 }
@@ -890,7 +890,7 @@
 template <class K, class T, class H, class P, class A>
 unordered_map<K,T,H,P,A>::unordered_map(
 unordered_map&& other, allocator_type const& a)
- : table_(other.table_, a, ::boost::unordered::detail::move_tag())
+ : table_(other.table_, a, boost::unordered::detail::move_tag())
 {
 }

@@ -903,7 +903,7 @@
 std::initializer_list<value_type> list, size_type n,
 const hasher &hf, const key_equal &eql, const allocator_type &a)
 : table_(
- ::boost::unordered::detail::initial_size(
+ boost::unordered::detail::initial_size(
 list.begin(), list.end(), n),
 hf, eql, a)
 {
@@ -1155,7 +1155,7 @@

 template <class K, class T, class H, class P, class A>
 unordered_multimap<K,T,H,P,A>::unordered_multimap(allocator_type const& a)
- : table_(::boost::unordered::detail::default_bucket_count,
+ : table_(boost::unordered::detail::default_bucket_count,
 hasher(), key_equal(), a)
 {
 }
@@ -1170,7 +1170,7 @@
 template <class K, class T, class H, class P, class A>
 template <class InputIt>
 unordered_multimap<K,T,H,P,A>::unordered_multimap(InputIt f, InputIt l)
- : table_(::boost::unordered::detail::initial_size(f, l),
+ : table_(boost::unordered::detail::initial_size(f, l),
 hasher(), key_equal(), allocator_type())
 {
 table_.insert_range(f, l);
@@ -1183,7 +1183,7 @@
 size_type n,
 const hasher &hf,
 const key_equal &eql)
- : table_(::boost::unordered::detail::initial_size(f, l, n),
+ : table_(boost::unordered::detail::initial_size(f, l, n),
 hf, eql, allocator_type())
 {
 table_.insert_range(f, l);
@@ -1197,7 +1197,7 @@
 const hasher &hf,
 const key_equal &eql,
 const allocator_type &a)
- : table_(::boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
+ : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
 {
 table_.insert_range(f, l);
 }
@@ -1217,7 +1217,7 @@
 template <class K, class T, class H, class P, class A>
 unordered_multimap<K,T,H,P,A>::unordered_multimap(
 unordered_multimap&& other, allocator_type const& a)
- : table_(other.table_, a, ::boost::unordered::detail::move_tag())
+ : table_(other.table_, a, boost::unordered::detail::move_tag())
 {
 }

@@ -1230,7 +1230,7 @@
 std::initializer_list<value_type> list, size_type n,
 const hasher &hf, const key_equal &eql, const allocator_type &a)
 : table_(
- ::boost::unordered::detail::initial_size(
+ boost::unordered::detail::initial_size(
 list.begin(), list.end(), n),
 hf, eql, a)
 {

Modified: trunk/boost/unordered/unordered_map_fwd.hpp
==============================================================================
--- trunk/boost/unordered/unordered_map_fwd.hpp (original)
+++ trunk/boost/unordered/unordered_map_fwd.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -37,11 +37,11 @@
unordered_multimap<K, T, H, P, A>&);
}

- using ::boost::unordered::unordered_map;
- using ::boost::unordered::unordered_multimap;
- using ::boost::unordered::swap;
- using ::boost::unordered::operator==;
- using ::boost::unordered::operator!=;
+ using boost::unordered::unordered_map;
+ using boost::unordered::unordered_multimap;
+ using boost::unordered::swap;
+ using boost::unordered::operator==;
+ using boost::unordered::operator!=;
}

#endif

Modified: trunk/boost/unordered/unordered_set.hpp
==============================================================================
--- trunk/boost/unordered/unordered_set.hpp (original)
+++ trunk/boost/unordered/unordered_set.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -52,14 +52,14 @@

 private:

- typedef typename ::boost::unordered::detail::rebind_wrap<
+ typedef typename boost::unordered::detail::rebind_wrap<
 allocator_type, value_type>::type
 value_allocator;

- typedef ::boost::unordered::detail::allocator_traits<value_allocator>
+ typedef boost::unordered::detail::allocator_traits<value_allocator>
 allocator_traits;

- typedef ::boost::unordered::detail::set<value_allocator, H, P>
+ typedef boost::unordered::detail::set<value_allocator, H, P>
 types;
 typedef typename types::table table;

@@ -88,7 +88,7 @@
 // constructors

 explicit unordered_set(
- size_type = ::boost::unordered::detail::default_bucket_count,
+ size_type = boost::unordered::detail::default_bucket_count,
 const hasher& = hasher(),
 const key_equal& = key_equal(),
 const allocator_type& = allocator_type());
@@ -120,7 +120,7 @@
 unordered_set(unordered_set const&, allocator_type const&);

 unordered_set(BOOST_RV_REF(unordered_set) other)
- : table_(other.table_, ::boost::unordered::detail::move_tag())
+ : table_(other.table_, boost::unordered::detail::move_tag())
 {
 }

@@ -131,7 +131,7 @@
#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
 unordered_set(
 std::initializer_list<value_type>,
- size_type = ::boost::unordered::detail::default_bucket_count,
+ size_type = boost::unordered::detail::default_bucket_count,
 const hasher& = hasher(),
 const key_equal&l = key_equal(),
 const allocator_type& = allocator_type());
@@ -235,7 +235,7 @@
 ) \
 { \
 return table_.emplace( \
- ::boost::unordered::detail::create_emplace_args( \
+ boost::unordered::detail::create_emplace_args( \
 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
 a) \
 )); \
@@ -250,7 +250,7 @@
 ) \
 { \
 return iterator(table_.emplace( \
- ::boost::unordered::detail::create_emplace_args( \
+ boost::unordered::detail::create_emplace_args( \
 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
 a) \
 )).first); \
@@ -427,14 +427,14 @@

 private:

- typedef typename ::boost::unordered::detail::rebind_wrap<
+ typedef typename boost::unordered::detail::rebind_wrap<
 allocator_type, value_type>::type
 value_allocator;

- typedef ::boost::unordered::detail::allocator_traits<value_allocator>
+ typedef boost::unordered::detail::allocator_traits<value_allocator>
 allocator_traits;

- typedef ::boost::unordered::detail::multiset<value_allocator, H, P>
+ typedef boost::unordered::detail::multiset<value_allocator, H, P>
 types;
 typedef typename types::table table;

@@ -463,7 +463,7 @@
 // constructors

 explicit unordered_multiset(
- size_type = ::boost::unordered::detail::default_bucket_count,
+ size_type = boost::unordered::detail::default_bucket_count,
 const hasher& = hasher(),
 const key_equal& = key_equal(),
 const allocator_type& = allocator_type());
@@ -495,7 +495,7 @@
 unordered_multiset(unordered_multiset const&, allocator_type const&);

 unordered_multiset(BOOST_RV_REF(unordered_multiset) other)
- : table_(other.table_, ::boost::unordered::detail::move_tag())
+ : table_(other.table_, boost::unordered::detail::move_tag())
 {
 }

@@ -506,7 +506,7 @@
#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
 unordered_multiset(
 std::initializer_list<value_type>,
- size_type = ::boost::unordered::detail::default_bucket_count,
+ size_type = boost::unordered::detail::default_bucket_count,
 const hasher& = hasher(),
 const key_equal&l = key_equal(),
 const allocator_type& = allocator_type());
@@ -610,7 +610,7 @@
 ) \
 { \
 return iterator(table_.emplace( \
- ::boost::unordered::detail::create_emplace_args( \
+ boost::unordered::detail::create_emplace_args( \
 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
 a) \
 ))); \
@@ -625,7 +625,7 @@
 ) \
 { \
 return iterator(table_.emplace( \
- ::boost::unordered::detail::create_emplace_args( \
+ boost::unordered::detail::create_emplace_args( \
 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
 a) \
 ))); \
@@ -800,7 +800,7 @@

 template <class T, class H, class P, class A>
 unordered_set<T,H,P,A>::unordered_set(allocator_type const& a)
- : table_(::boost::unordered::detail::default_bucket_count,
+ : table_(boost::unordered::detail::default_bucket_count,
 hasher(), key_equal(), a)
 {
 }
@@ -815,7 +815,7 @@
 template <class T, class H, class P, class A>
 template <class InputIt>
 unordered_set<T,H,P,A>::unordered_set(InputIt f, InputIt l)
- : table_(::boost::unordered::detail::initial_size(f, l),
+ : table_(boost::unordered::detail::initial_size(f, l),
 hasher(), key_equal(), allocator_type())
 {
 table_.insert_range(f, l);
@@ -828,7 +828,7 @@
 size_type n,
 const hasher &hf,
 const key_equal &eql)
- : table_(::boost::unordered::detail::initial_size(f, l, n),
+ : table_(boost::unordered::detail::initial_size(f, l, n),
 hf, eql, allocator_type())
 {
 table_.insert_range(f, l);
@@ -842,7 +842,7 @@
 const hasher &hf,
 const key_equal &eql,
 const allocator_type &a)
- : table_(::boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
+ : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
 {
 table_.insert_range(f, l);
 }
@@ -862,7 +862,7 @@
 template <class T, class H, class P, class A>
 unordered_set<T,H,P,A>::unordered_set(
 unordered_set&& other, allocator_type const& a)
- : table_(other.table_, a, ::boost::unordered::detail::move_tag())
+ : table_(other.table_, a, boost::unordered::detail::move_tag())
 {
 }

@@ -875,7 +875,7 @@
 std::initializer_list<value_type> list, size_type n,
 const hasher &hf, const key_equal &eql, const allocator_type &a)
 : table_(
- ::boost::unordered::detail::initial_size(
+ boost::unordered::detail::initial_size(
 list.begin(), list.end(), n),
 hf, eql, a)
 {
@@ -1078,7 +1078,7 @@

 template <class T, class H, class P, class A>
 unordered_multiset<T,H,P,A>::unordered_multiset(allocator_type const& a)
- : table_(::boost::unordered::detail::default_bucket_count,
+ : table_(boost::unordered::detail::default_bucket_count,
 hasher(), key_equal(), a)
 {
 }
@@ -1093,7 +1093,7 @@
 template <class T, class H, class P, class A>
 template <class InputIt>
 unordered_multiset<T,H,P,A>::unordered_multiset(InputIt f, InputIt l)
- : table_(::boost::unordered::detail::initial_size(f, l),
+ : table_(boost::unordered::detail::initial_size(f, l),
 hasher(), key_equal(), allocator_type())
 {
 table_.insert_range(f, l);
@@ -1106,7 +1106,7 @@
 size_type n,
 const hasher &hf,
 const key_equal &eql)
- : table_(::boost::unordered::detail::initial_size(f, l, n),
+ : table_(boost::unordered::detail::initial_size(f, l, n),
 hf, eql, allocator_type())
 {
 table_.insert_range(f, l);
@@ -1120,7 +1120,7 @@
 const hasher &hf,
 const key_equal &eql,
 const allocator_type &a)
- : table_(::boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
+ : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
 {
 table_.insert_range(f, l);
 }
@@ -1140,7 +1140,7 @@
 template <class T, class H, class P, class A>
 unordered_multiset<T,H,P,A>::unordered_multiset(
 unordered_multiset&& other, allocator_type const& a)
- : table_(other.table_, a, ::boost::unordered::detail::move_tag())
+ : table_(other.table_, a, boost::unordered::detail::move_tag())
 {
 }

@@ -1153,7 +1153,7 @@
 std::initializer_list<value_type> list, size_type n,
 const hasher &hf, const key_equal &eql, const allocator_type &a)
 : table_(
- ::boost::unordered::detail::initial_size(
+ boost::unordered::detail::initial_size(
 list.begin(), list.end(), n),
 hf, eql, a)
 {

Modified: trunk/boost/unordered/unordered_set_fwd.hpp
==============================================================================
--- trunk/boost/unordered/unordered_set_fwd.hpp (original)
+++ trunk/boost/unordered/unordered_set_fwd.hpp 2011-10-06 04:03:25 EDT (Thu, 06 Oct 2011)
@@ -37,11 +37,11 @@
unordered_multiset<T, H, P, A> &m2);
}

- using ::boost::unordered::unordered_set;
- using ::boost::unordered::unordered_multiset;
- using ::boost::unordered::swap;
- using ::boost::unordered::operator==;
- using ::boost::unordered::operator!=;
+ using boost::unordered::unordered_set;
+ using boost::unordered::unordered_multiset;
+ using boost::unordered::swap;
+ using boost::unordered::operator==;
+ using boost::unordered::operator!=;
}

#endif

Next message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r74751 - trunk/libs/timer/test"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r74749 - in trunk/boost/chrono: io stopwatches stopwatches/collectors"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk