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]

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]

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
+
     }
 }
 

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>

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;

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);

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)) {

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))));
         }

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_);

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;
+    using namespace std;
-   	srand(14878);
+    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();
+        int count = rand() % 10, index = rand();
-    	for(int j = 0; j < count; ++j)
+        for(int j = 0; j < count; ++j)
-	    	multiset.insert(index);
+            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();
+        int count = rand() % 10, index = rand();
-    	for(int j = 0; j < count; ++j)
+        for(int j = 0; j < count; ++j)
-	    	multimap.insert(std::pair<const int, int>(index, rand()));
+            multimap.insert(std::pair<const int, int>(index, rand()));
     }
     simple_test(multimap);