Merged revisions 42856-42881 via svnmerge from

https://svn.boost.org/svn/boost/branches/unordered/trunk

........
  r42880 | danieljames | 2008-01-20 16:10:43 +0000 (Sun, 20 Jan 2008) | 17 lines
  
  Simplify the tests a little:
  
  Add a parameter to random_values to control what sort of values it generates.
  This means that instead of using equivalent_object to test collisions (which
  was a total hack) we now just need another parameter.
  
  This requires some meta programming to act differently for maps and sets.
  Because of this pairs no longer need to be generated so remove the code for
  doing that (which doesn't work on some compilers).
  
  Remove the generator object, just call generate directly.
  
  Remove some of the tests using int containers, they didn't really add to
  anthing other than the compile time (some tests are timing out).
........


[SVN r42882]

test/helpers/fwd.hpp

@@ -15,8 +15,6 @@ namespace test
     signed char generate(signed char const*);
     std::string generate(std::string*);
     float generate(float const*);
-    template <class T1, class T2>
-    std::pair<T1, T2> generate(std::pair<T1, T2>*);
 
     struct base_type {} base;
     struct derived_type : base_type {} derived;

test/helpers/generators.hpp

@@ -16,7 +16,6 @@
 #include <stdexcept>
 #include <cstdlib>
 #include <boost/type_traits/add_const.hpp>
-
 #include "./fwd.hpp"
 
 namespace test
@@ -27,29 +26,6 @@ namespace test
             srand(x);
         }
     };
-    
-    template <class T>
-    struct generator;
-
-    template <class T1, class T2> std::pair<T1, T2> generate(
-            std::pair<T1, T2> const*)
-    {
-        static generator<T1> g1;
-        static generator<T2> g2;
-
-        return std::pair<T1, T2>(g1(), g2());
-    }
-
-    template <class T>
-    struct generator
-    {
-        typedef T value_type;
-        typedef BOOST_DEDUCED_TYPENAME boost::add_const<T>::type const_value_type;
-        value_type operator()() const
-        {
-            return generate((const_value_type*) 0);
-        }
-    };
 
     inline int generate(int const*)
     {
@@ -73,13 +49,13 @@ namespace test
     {
         using namespace std;
 
-        static test::generator<char> char_gen;
+        char* char_ptr = 0;
 
         std::string result;
 
         int length = rand() % 10;
         for(int i = 0; i < length; ++i)
-            result += char_gen();
+            result += generate(char_ptr);
 
         return result;
     }

test/helpers/random_values.hpp

@@ -8,18 +8,102 @@
 
 #include <list>
 #include <algorithm>
+#include <boost/mpl/if.hpp>
 #include "./generators.hpp"
+#include "./metafunctions.hpp"
 
 namespace test
 {
+    typedef enum {
+        default_generator,
+        generate_collisions
+    } random_generator;
+
+    template <class X>
+    struct unordered_generator_set
+    {
+        typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
+
+        random_generator type_;
+
+        unordered_generator_set(random_generator type)
+            : type_(type) {}
+
+        template <class T>
+        void fill(T& x, std::size_t len) {
+            value_type* value_ptr = 0;
+            int* int_ptr = 0;
+
+            for(std::size_t i = 0; i < len; ++i) {
+                value_type value = generate(value_ptr);
+
+                for(int count =
+                    type_ == generate_collisions ?
+                    generate(int_ptr) % 10 : 1;
+                    count; --count) {
+                    x.push_back(value);
+                }
+            }
+        }
+    };
+
+    template <class X>
+    struct unordered_generator_map
+    {
+        typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
+        typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type;
+
+        random_generator type_;
+
+        unordered_generator_map(random_generator type)
+            : type_(type) {}
+
+        template <class T>
+        void fill(T& x, std::size_t len) {
+            key_type* key_ptr = 0;
+            mapped_type* mapped_ptr = 0;
+            int* int_ptr = 0;
+
+            for(std::size_t i = 0; i < len; ++i) {
+                key_type key = generate(key_ptr);
+
+                for(int count =
+                    type_ == generate_collisions ?
+                    generate(int_ptr) % 10 : 1;
+                    count; --count) {
+                    x.push_back(std::pair<key_type const, mapped_type>(key, generate(mapped_ptr)));
+                }
+            }
+        }
+    };
+
+    template <class X>
+    struct unordered_generator_base
+        : public boost::mpl::if_<
+            test::is_set<X>,
+            test::unordered_generator_set<X>,
+            test::unordered_generator_map<X> >
+    {
+    };
+
+    template <class X>
+    struct unordered_generator : public unordered_generator_base<X>::type
+    {
+        typedef BOOST_DEDUCED_TYPENAME unordered_generator_base<X>::type base;
+
+        unordered_generator(random_generator const& type = default_generator)
+            : base(type) {}
+    };
+
     template <class X>
     struct random_values
         : public std::list<BOOST_DEDUCED_TYPENAME X::value_type>
     {
-        random_values(int count) {
-            typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
-            static test::generator<value_type> gen;
-            std::generate_n(std::back_inserter(*this), count, gen);
+        random_values(int count, test::random_generator const& generator =
+			test::default_generator)
+        {
+            static test::unordered_generator<X> gen(generator);
+            gen.fill(*this, count);
         }
     };
 }