Merged revisions 42882-42941 via svnmerge from

https://svn.boost.org/svn/boost/branches/unordered/trunk ................ r42887 | danieljames | 2008-01-20 21:32:04 +0000 (Sun, 20 Jan 2008) | 10 lines Merged revisions 42590-42664,42667-42697,42699-42723,42725-42855,42857-42881 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r42881 | danieljames | 2008-01-20 17:37:21 +0000 (Sun, 20 Jan 2008) | 1 line Include <new> to get std::bad_alloc. ........ ................ r42892 | danieljames | 2008-01-21 13:03:16 +0000 (Mon, 21 Jan 2008) | 1 line On some compilers the Rogue Wave/Apache stdcxx library doesn't have the normal std::distance, but instead has a variant that takes the result as the third parameter so it doesn't have to work out the type from the iterator. ................ r42893 | danieljames | 2008-01-21 13:07:58 +0000 (Mon, 21 Jan 2008) | 1 line Fix a typo in the last commit. ................ r42895 | danieljames | 2008-01-21 13:33:29 +0000 (Mon, 21 Jan 2008) | 1 line Remove tabs from the last checkin. ................ r42896 | danieljames | 2008-01-21 15:51:40 +0000 (Mon, 21 Jan 2008) | 1 line Use Boost config to tell when we have a std::distance function. Also, no need for a macro. ................ r42908 | danieljames | 2008-01-21 21:37:04 +0000 (Mon, 21 Jan 2008) | 1 line Use boost::long_long_type and boost::ulong_long_type. ................ r42921 | danieljames | 2008-01-23 11:43:35 +0000 (Wed, 23 Jan 2008) | 1 line Remove some tabs. ................ r42922 | danieljames | 2008-01-23 11:46:28 +0000 (Wed, 23 Jan 2008) | 2 lines Add missing include. Refs #1596 ................ r42923 | danieljames | 2008-01-23 11:52:47 +0000 (Wed, 23 Jan 2008) | 2 lines Always use void const* for the second parameter of allocate. Refs #1596. ................ r42936 | danieljames | 2008-01-23 22:22:16 +0000 (Wed, 23 Jan 2008) | 1 line Use Boost style library name in the documentation. ................ r42937 | danieljames | 2008-01-23 22:22:32 +0000 (Wed, 23 Jan 2008) | 1 line More tabs. ................ r42941 | danieljames | 2008-01-23 23:35:01 +0000 (Wed, 23 Jan 2008) | 1 line Fix all the allocators. ................ [SVN r42943]
2025-07-30 19:37:14 +02:00 · 2008-01-23 23:39:59 +00:00
parent b1ba0f65c8
commit b72206e5a0
9 changed files with 32 additions and 24 deletions
--- a/doc/unordered.qbk
+++ b/doc/unordered.qbk
@ -2,7 +2,7 @@
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ]

-[library Unordered Associative Containers
+[library Boost.Unordered
    [quickbook 1.4]
    [authors [James, Daniel]]
    [copyright 2003 2004 Jeremy B. Maitin-Shepard]
--- a/include/boost/unordered/detail/hash_table.hpp
+++ b/include/boost/unordered/detail/hash_table.hpp
@ -109,6 +109,18 @@ namespace boost {
        {
            return std::pair<Dst1, Dst2>(Dst1(x.first), Dst2(x.second));
        }
+
+#if !defined(BOOST_NO_STD_DISTANCE)
+        using ::std::distance;
+#else
+        template <class ForwardIterator>
+        inline std::size_t distance(ForwardIterator i, ForwardIterator j) {
+            std::size_t x;
+            std::distance(i, j, x);
+            return x;
+        }
+#endif
+
    }
 }

--- a/include/boost/unordered/detail/hash_table_impl.hpp
+++ b/include/boost/unordered/detail/hash_table_impl.hpp
@ -1045,7 +1045,7 @@ namespace boost {
                    boost::forward_traversal_tag)
            {
                // max load factor isn't set yet, but when it is, it'll be 1.0.
-                return (std::max)(static_cast<size_type>(std::distance(i, j)) + 1, n);
+                return (std::max)(static_cast<size_type>(unordered_detail::distance(i, j)) + 1, n);
            }

            template <typename I>
@ -1312,7 +1312,7 @@ namespace boost {
                // throws - basic:
                if (need_to_reserve) {
                    rehash_impl(double_to_size_t(floor(
-                    	n / (double) mlf_ * 1.25)) + 1);
+                        n / (double) mlf_ * 1.25)) + 1);
                }
                BOOST_ASSERT(n < max_load_ || n > max_size());
                return need_to_reserve;
@ -1545,7 +1545,7 @@ namespace boost {
            template <typename I>
            void insert_for_range(I i, I j, forward_traversal_tag)
            {
-                size_type distance = std::distance(i, j);
+                size_type distance = unordered_detail::distance(i, j);
                if(distance == 1) {
                    insert(*i);
                }
@ -1687,7 +1687,7 @@ namespace boost {
            template <typename I>
            size_type insert_size(I i, I j, boost::forward_traversal_tag)
            {
-                return std::distance(i, j);
+                return unordered_detail::distance(i, j);
            }

            template <typename I>
--- a/test/helpers/allocator.hpp
+++ b/test/helpers/allocator.hpp
@ -45,13 +45,7 @@ namespace test
            return ptr;
        }

-        pointer allocate(size_type n, const_pointer u) { return allocate(n); }
-
-#if defined(__IBMCPP__) || BOOST_WORKAROUND(BOOST_RWSTD_VER, < 0x04020000)
-        // Workaround for IBM Visual Age and Rogue Wave (or maybe just Apache stdcxx?)
-        // which seem to use a void pointer for the second argument.
        pointer allocate(size_type n, void const* u) { return allocate(n); }
-#endif

        void deallocate(pointer p, size_type) {
            using namespace std;
--- a/test/helpers/random_values.hpp
+++ b/test/helpers/random_values.hpp
@ -100,7 +100,7 @@ namespace test
        : public std::list<BOOST_DEDUCED_TYPENAME X::value_type>
    {
        random_values(int count, test::random_generator const& generator =
-			test::default_generator)
+            test::default_generator)
        {
            static test::unordered_generator<X> gen(generator);
            gen.fill(*this, count);
--- a/test/objects/exception.hpp
+++ b/test/objects/exception.hpp
@ -313,7 +313,7 @@ namespace exception
            //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
        }

-        pointer allocate(size_type n, const_pointer u)
+        pointer allocate(size_type n, void const* u)
        {
            T* ptr = 0;
            UNORDERED_SCOPE(allocator::allocate(size_type, const_pointer)) {
--- a/test/objects/minimal.hpp
+++ b/test/objects/minimal.hpp
@ -195,7 +195,8 @@ namespace minimal
            return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
        }

-        pointer allocate(size_type n, const_pointer u)
+        template <class Y>
+        pointer allocate(size_type n, const_ptr<Y> u)
        {
            return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
        }
--- a/test/objects/test.hpp
+++ b/test/objects/test.hpp
@ -194,7 +194,7 @@ namespace test
            return ptr;
        }

-        pointer allocate(size_type n, const_pointer u)
+        pointer allocate(size_type n, void const* u)
        {
            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
--- a/test/unordered/simple_tests.cpp
+++ b/test/unordered/simple_tests.cpp
@ -8,6 +8,7 @@
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include <cstdlib>
 #include <algorithm>
 #include "../helpers/equivalent.hpp"

@ -84,8 +85,8 @@ void simple_test(X const& a)

 int main()
 {
-  	using namespace std;
-   	srand(14878);
+    using namespace std;
+    srand(14878);

    std::cout<<"Test unordered_set.\n";
    boost::unordered_set<int> set;
@ -99,9 +100,9 @@ int main()
    simple_test(multiset);
    
    for(int i1 = 0; i1 < 1000; ++i1) {
-    	int count = rand() % 10, index = rand();
-    	for(int j = 0; j < count; ++j)
-	    	multiset.insert(index);
+        int count = rand() % 10, index = rand();
+        for(int j = 0; j < count; ++j)
+            multiset.insert(index);
    }
    simple_test(multiset);
    
@ -109,7 +110,7 @@ int main()
    boost::unordered_map<int, int> map;

    for(int i2 = 0; i2 < 1000; ++i2) {
-    	map.insert(std::pair<const int, int>(rand(), rand()));
+        map.insert(std::pair<const int, int>(rand(), rand()));
    }
    simple_test(map);

@ -117,9 +118,9 @@ int main()
    boost::unordered_multimap<int, int> multimap;

    for(int i3 = 0; i3 < 1000; ++i3) {
-    	int count = rand() % 10, index = rand();
-    	for(int j = 0; j < count; ++j)
-	    	multimap.insert(std::pair<const int, int>(index, rand()));
+        int count = rand() % 10, index = rand();
+        for(int j = 0; j < count; ++j)
+            multimap.insert(std::pair<const int, int>(index, rand()));
    }
    simple_test(multimap);