ceph/src/boost/libs/unordered/test/helpers/random_values.hpp

   1
   2 // Copyright 2005-2009 Daniel James.
   3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #if !defined(BOOST_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER)
   7 #define BOOST_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER
   8
   9 #include "./generators.hpp"
  10 #include "./list.hpp"
  11 #include "./metafunctions.hpp"
  12 #include <algorithm>
  13 #include <boost/detail/select_type.hpp>
  14
  15 namespace test {
  16   template <class X> struct unordered_generator_set
  17   {
  18     typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
  19
  20     random_generator type_;
  21
  22     unordered_generator_set(random_generator type) : type_(type) {}
  23
  24     template <class T> void fill(T& x, std::size_t len)
  25     {
  26       value_type* value_ptr = 0;
  27       len += x.size();
  28
  29       for (std::size_t i = 0; i < len; ++i) {
  30         value_type value = generate(value_ptr, type_);
  31
  32         std::size_t count =
  33           type_ == generate_collisions ? random_value(5) + 1 : 1;
  34
  35         for (std::size_t j = 0; j < count; ++j) {
  36           x.push_back(value);
  37         }
  38       }
  39     }
  40   };
  41
  42   template <class X> struct unordered_generator_map
  43   {
  44     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
  45     typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type;
  46
  47     random_generator type_;
  48
  49     unordered_generator_map(random_generator type) : type_(type) {}
  50
  51     template <class T> void fill(T& x, std::size_t len)
  52     {
  53       key_type* key_ptr = 0;
  54       mapped_type* mapped_ptr = 0;
  55
  56       for (std::size_t i = 0; i < len; ++i) {
  57         key_type key = generate(key_ptr, type_);
  58
  59         std::size_t count =
  60           type_ == generate_collisions ? random_value(5) + 1 : 1;
  61
  62         for (std::size_t j = 0; j < count; ++j) {
  63           x.push_back(std::pair<key_type const, mapped_type>(
  64             key, generate(mapped_ptr, type_)));
  65         }
  66       }
  67     }
  68   };
  69
  70   template <class X>
  71   struct unordered_generator_base
  72     : public boost::detail::if_true<test::is_set<X>::value>::
  73         BOOST_NESTED_TEMPLATE then<test::unordered_generator_set<X>,
  74           test::unordered_generator_map<X> >
  75   {
  76   };
  77
  78   template <class X>
  79   struct unordered_generator : public unordered_generator_base<X>::type
  80   {
  81     typedef BOOST_DEDUCED_TYPENAME unordered_generator_base<X>::type base;
  82
  83     unordered_generator(random_generator const& type = default_generator)
  84         : base(type)
  85     {
  86     }
  87   };
  88
  89   template <class X>
  90   struct random_values : public test::list<BOOST_DEDUCED_TYPENAME X::value_type>
  91   {
  92     random_values() {}
  93
  94     explicit random_values(std::size_t count,
  95       test::random_generator const& generator = test::default_generator)
  96     {
  97       fill(count, generator);
  98     }
  99
 100     void fill(std::size_t count,
 101       test::random_generator const& generator = test::default_generator)
 102     {
 103       test::unordered_generator<X> gen(generator);
 104       gen.fill(*this, count);
 105     }
 106   };
 107 }
 108
 109 #endif