[Boost-commit] svn:boost r52747 - sandbox/move/boost/unordered/detail

Subject: [Boost-commit] svn:boost r52747 - sandbox/move/boost/unordered/detail
From: daniel_james_at_[hidden]
Date: 2009-05-03 06:15:35

Author: danieljames
Date: 2009-05-03 06:15:35 EDT (Sun, 03 May 2009)
New Revision: 52747
URL: http://svn.boost.org/trac/boost/changeset/52747

Log:
Put the C++0x emplace implementations before the non-C++0x versions.

I'm going to change the non-C++0x to be macro heavy emulations of the
C++0x versions, so this will put the readable version first.
Text files modified: 
   sandbox/move/boost/unordered/detail/hash_table_impl.hpp |   155 ++++++++++++++++++++------------------- 
   1 files changed, 78 insertions(+), 77 deletions(-)

Modified: sandbox/move/boost/unordered/detail/hash_table_impl.hpp
==============================================================================
--- sandbox/move/boost/unordered/detail/hash_table_impl.hpp	(original)
+++ sandbox/move/boost/unordered/detail/hash_table_impl.hpp	2009-05-03 06:15:35 EDT (Sun, 03 May 2009)
@@ -1599,31 +1599,36 @@
 
 #if BOOST_UNORDERED_EQUIVALENT_KEYS
 
-#if !(defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL))
-            // Insert (equivalent key containers)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+
+            // Emplace (equivalent key containers)
+            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
 
             // if hash function throws, basic exception safety
             // strong otherwise
-            iterator_base emplace(value_type const& v)
+            template <class... Args>
+            iterator_base emplace(Args&&... args)
             {
                 // Create the node before rehashing in case it throws an
                 // exception (need strong safety in such a case).
                 node_constructor a(data_.allocators_);
-                a.construct(v);
+                a.construct(std::forward<Args>(args)...);
 
                 return emplace_impl(a);
             }
 
-            // Insert (equivalent key containers)
+            // Emplace (equivalent key containers)
+            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
 
             // if hash function throws, basic exception safety
             // strong otherwise
-            iterator_base emplace_hint(iterator_base const& it, value_type const& v)
+            template <class... Args>
+            iterator_base emplace_hint(iterator_base const& it, Args&&... args)
             {
                 // Create the node before rehashing in case it throws an
                 // exception (need strong safety in such a case).
                 node_constructor a(data_.allocators_);
-                a.construct(v);
+                a.construct(std::forward<Args>(args)...);
 
                 return emplace_hint_impl(it, a);
             }
@@ -1631,33 +1636,29 @@
 #else
 
             // Emplace (equivalent key containers)
-            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
 
             // if hash function throws, basic exception safety
             // strong otherwise
-            template <class... Args>
-            iterator_base emplace(Args&&... args)
+            iterator_base emplace(value_type const& v)
             {
                 // Create the node before rehashing in case it throws an
                 // exception (need strong safety in such a case).
                 node_constructor a(data_.allocators_);
-                a.construct(std::forward<Args>(args)...);
+                a.construct(v);
 
                 return emplace_impl(a);
             }
 
-            // Insert (equivalent key containers)
-            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
+            // Emplace (equivalent key containers)
 
             // if hash function throws, basic exception safety
             // strong otherwise
-            template <class... Args>
-            iterator_base emplace_hint(iterator_base const& it, Args&&... args)
+            iterator_base emplace_hint(iterator_base const& it, value_type const& v)
             {
                 // Create the node before rehashing in case it throws an
                 // exception (need strong safety in such a case).
                 node_constructor a(data_.allocators_);
-                a.construct(std::forward<Args>(args)...);
+                a.construct(v);
 
                 return emplace_hint_impl(it, a);
             }
@@ -1689,13 +1690,13 @@
             {
                 // equal can throw, but with no effects
                 if (it == data_.end() || !equal(extract_key(a.get()->value()), *it)) {
-                    // Use the standard insert if the iterator doesn't point
+                    // Use the standard emplace if the iterator doesn't point
                     // to a matching key.
                     return emplace_impl(a);
                 }
                 else {
                     // Find the first node in the group - so that the node
-                    // will be inserted at the end of the group.
+                    // will be added at the end of the group.
 
                     link_ptr start(it.node_);
                     while(data_.prev_in_group(start)->next_ == start)
@@ -1803,64 +1804,10 @@
                 }
             }
 
-#if !(defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL))
-
-            // Insert (unique keys)
-
-            // if hash function throws, basic exception safety
-            // strong otherwise
-            std::pair<iterator_base, bool> emplace(value_type const& v)
-            {
-                // No side effects in this initial code
-                key_type const& k = extract_key(v);
-                size_type hash_value = hash_function()(k);
-                bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value);
-                link_ptr pos = find_iterator(bucket, k);
-
-                if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
-                    // Found an existing key, return it (no throw).
-                    return std::pair<iterator_base, bool>(
-                        iterator_base(bucket, pos), false);
-
-                } else {
-                    // Doesn't already exist, add to bucket.
-                    // Side effects only in this block.
-
-                    // Create the node before rehashing in case it throws an
-                    // exception (need strong safety in such a case).
-                    node_constructor a(data_.allocators_);
-                    a.construct(v);
-
-                    // reserve has basic exception safety if the hash function
-                    // throws, strong otherwise.
-                    if(reserve_for_insert(size() + 1))
-                        bucket = data_.bucket_ptr_from_hash(hash_value);
-
-                    // Nothing after this point can throw.
-
-                    link_ptr n = data_.link_node_in_bucket(a, bucket);
-
-                    return std::pair<iterator_base, bool>(
-                        iterator_base(bucket, n), true);
-                }
-            }
-
-            // Insert (unique keys)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
 
-            // if hash function throws, basic exception safety
-            // strong otherwise
-            iterator_base emplace_hint(iterator_base const& it, value_type const& v)
-            {
-                if(it != data_.end() && equal(extract_key(v), *it))
-                    return it;
-                else
-                    return emplace(v).first;
-            }
-
-#else
-
-            // Insert (unique keys)
-            // (I'm using an overloaded insert for both 'insert' and 'emplace')
+            // Emplace (unique keys)
+            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
             //
             // TODO:
             // For sets: create a local key without creating the node?
@@ -1941,8 +1888,8 @@
                 }
             }
 
-            // Insert (unique keys)
-            // (I'm using an overloaded insert for both 'insert' and 'emplace')
+            // Emplace (unique keys)
+            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
 
             // if hash function throws, basic exception safety
             // strong otherwise
@@ -1952,6 +1899,60 @@
                 // Life is complicated - just call the normal implementation.
                 return emplace(std::forward<Args>(args)...).first;
             }
+#else
+
+            // Emplace (unique keys)
+
+            // if hash function throws, basic exception safety
+            // strong otherwise
+            std::pair<iterator_base, bool> emplace(value_type const& v)
+            {
+                // No side effects in this initial code
+                key_type const& k = extract_key(v);
+                size_type hash_value = hash_function()(k);
+                bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value);
+                link_ptr pos = find_iterator(bucket, k);
+
+                if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
+                    // Found an existing key, return it (no throw).
+                    return std::pair<iterator_base, bool>(
+                        iterator_base(bucket, pos), false);
+
+                } else {
+                    // Doesn't already exist, add to bucket.
+                    // Side effects only in this block.
+
+                    // Create the node before rehashing in case it throws an
+                    // exception (need strong safety in such a case).
+                    node_constructor a(data_.allocators_);
+                    a.construct(v);
+
+                    // reserve has basic exception safety if the hash function
+                    // throws, strong otherwise.
+                    if(reserve_for_insert(size() + 1))
+                        bucket = data_.bucket_ptr_from_hash(hash_value);
+
+                    // Nothing after this point can throw.
+
+                    link_ptr n = data_.link_node_in_bucket(a, bucket);
+
+                    return std::pair<iterator_base, bool>(
+                        iterator_base(bucket, n), true);
+                }
+            }
+
+            // Emplace (unique keys)
+
+            // if hash function throws, basic exception safety
+            // strong otherwise
+            iterator_base emplace_hint(iterator_base const& it, value_type const& v)
+            {
+                if(it != data_.end() && equal(extract_key(v), *it))
+                    return it;
+                else
+                    return emplace(v).first;
+            }
+
 #endif
 
             // Insert from iterators (unique keys)