ceph/src/boost/libs/unordered/test/unordered/deduction_tests.cpp

   1
   2 // Copyright 2017-2018 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 #include <boost/unordered_map.hpp>
   7 #include <iostream>
   8 #include <vector>
   9
  10 #if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
  11 struct hash_equals
  12 {
  13   template <typename T> bool operator()(T const& x) const
  14   {
  15     boost::hash<T> hf;
  16     return hf(x);
  17   }
  18
  19   template <typename T> bool operator()(T const& x, T const& y) const
  20   {
  21     std::equal_to<T> eq;
  22     return eq(x, y);
  23   }
  24 };
  25
  26 template <typename T> struct test_allocator
  27 {
  28   typedef T value_type;
  29   test_allocator() = default;
  30   template <typename T2> test_allocator(test_allocator<T2> const&) {}
  31   T* allocate(std::size_t n) const { return (T*)malloc(sizeof(T) * n); }
  32   void deallocate(T* ptr, std::size_t) const { free(ptr); }
  33   bool operator==(test_allocator const&) const { return true; }
  34   bool operator!=(test_allocator const&) const { return false; }
  35 };
  36 #endif
  37
  38 int main()
  39 {
  40   std::cout << "BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES: "
  41             << BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES << std::endl;
  42
  43 #if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
  44   std::vector<std::pair<int, int> > x;
  45   x.push_back(std::make_pair(1, 3));
  46   x.push_back(std::make_pair(5, 10));
  47   test_allocator<std::pair<const int, int> > pair_allocator;
  48   hash_equals f;
  49
  50   // unordered_map
  51
  52   /*
  53    template<class InputIterator,
  54            class Hash = hash<iter_key_t<InputIterator>>,
  55            class Pred = equal_to<iter_key_t<InputIterator>>,
  56            class Allocator = allocator<iter_to_alloc_t<InputIterator>>>
  57     unordered_map(InputIterator, InputIterator, typename see below::size_type =
  58    see below,
  59                   Hash = Hash(), Pred = Pred(), Allocator = Allocator())
  60       -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
  61    Hash, Pred,
  62                        Allocator>;
  63   */
  64
  65   {
  66     boost::unordered_map m(x.begin(), x.end());
  67     static_assert(
  68       std::is_same<decltype(m), boost::unordered_map<int, int> >::value);
  69   }
  70
  71   /* Ambiguous:
  72   {
  73     boost::unordered_map m(x.begin(), x.end(), 0, std::hash<int>());
  74     static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
  75   std::hash<int>>>::value);
  76   }
  77
  78   {
  79     boost::unordered_map m(x.begin(), x.end(), 0, std::hash<int>(),
  80   std::equal_to<int>());
  81     static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
  82   std::hash<int>, std::equal_to<int>>>::value);
  83   }
  84   */
  85
  86   {
  87     boost::unordered_map m(x.begin(), x.end(), 0, std::hash<int>(),
  88       std::equal_to<int>(), pair_allocator);
  89     static_assert(std::is_same<decltype(m),
  90       boost::unordered_map<int, int, std::hash<int>, std::equal_to<int>,
  91         test_allocator<std::pair<const int, int> > > >::value);
  92   }
  93
  94   /*
  95   template<class Key, class T, class Hash = hash<Key>,
  96            class Pred = equal_to<Key>, class Allocator = allocator<pair<const
  97   Key, T>>>
  98     unordered_map(initializer_list<pair<const Key, T>>,
  99                   typename see below::size_type = see below, Hash = Hash(),
 100                   Pred = Pred(), Allocator = Allocator())
 101       -> unordered_map<Key, T, Hash, Pred, Allocator>;
 102   */
 103
 104   {
 105     boost::unordered_map m({std::pair<int const, int>(1, 2)});
 106     static_assert(
 107       std::is_same<decltype(m), boost::unordered_map<int, int> >::value);
 108   }
 109
 110   /* Ambiguous
 111   {
 112     boost::unordered_map m({std::pair<int const, int>(1,2)}, 0,
 113   std::hash<int>());
 114     static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
 115   std::hash<int>>>::value);
 116   }
 117
 118   {
 119     boost::unordered_map m({std::pair<int const, int>(1,2)}, 0,
 120   std::hash<int>(), std::equal_to<int>());
 121     static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
 122   std::hash<int>, std::equal_to<int>>>::value);
 123   }
 124   */
 125
 126   {
 127     boost::unordered_map m(
 128       {std::pair<int const, int>(1, 2)}, 0, f, f, pair_allocator);
 129     static_assert(std::is_same<decltype(m),
 130       boost::unordered_map<int, int, hash_equals, hash_equals,
 131         test_allocator<std::pair<const int, int> > > >::value);
 132   }
 133
 134   /*
 135   template<class InputIterator, class Allocator>
 136     unordered_map(InputIterator, InputIterator, typename see below::size_type,
 137   Allocator)
 138       -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
 139                        hash<iter_key_t<InputIterator>>,
 140   equal_to<iter_key_t<InputIterator>>,
 141                        Allocator>;
 142   */
 143
 144   /* Ambiguous
 145   {
 146     boost::unordered_map m(x.begin(), x.end(), 0u, pair_allocator);
 147     static_assert(std::is_same<decltype(m), boost::unordered_map<int, int,
 148   boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
 149   int>>>>::value);
 150   }
 151   */
 152
 153   /*
 154     template<class InputIterator, class Allocator>
 155     unordered_map(InputIterator, InputIterator, Allocator)
 156       -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
 157                        hash<iter_key_t<InputIterator>>,
 158     equal_to<iter_key_t<InputIterator>>,
 159                        Allocator>;
 160   */
 161
 162   /* No constructor:
 163   {
 164     boost::unordered_map m(x.begin(), x.end(), pair_allocator);
 165     static_assert(std::is_same<decltype(m), boost::unordered_map<int, int,
 166   boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
 167   int>>>>::value);
 168   }
 169   */
 170
 171   /*
 172   template<class InputIterator, class Hash, class Allocator>
 173     unordered_map(InputIterator, InputIterator, typename see below::size_type,
 174   Hash, Allocator)
 175       -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
 176   Hash,
 177                        equal_to<iter_key_t<InputIterator>>, Allocator>;
 178   */
 179
 180   /* Ambiguous
 181   {
 182     boost::unordered_map m(x.begin(), x.end(), 0u, f, pair_allocator);
 183     static_assert(std::is_same<decltype(m), boost::unordered_map<int, int,
 184   hash_equals, std::equal_to<int>, test_allocator<std::pair<const int,
 185   int>>>>::value);
 186   }
 187   */
 188
 189   /*
 190     template<class Key, class T, typename Allocator>
 191     unordered_map(initializer_list<pair<const Key, T>>, typename see
 192     below::size_type,
 193                   Allocator)
 194       -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
 195   */
 196
 197   /* Ambiguous
 198   {
 199     boost::unordered_map m({std::pair<int const, int>(1,2)}, 0, pair_allocator);
 200     static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
 201   boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
 202   int>>>>::value);
 203   }
 204   */
 205
 206   /*
 207   template<class Key, class T, typename Allocator>
 208     unordered_map(initializer_list<pair<const Key, T>>, Allocator)
 209       -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
 210   */
 211
 212   {
 213     boost::unordered_map m({std::pair<int const, int>(1, 2)}, pair_allocator);
 214     static_assert(std::is_same<decltype(m),
 215       boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
 216         test_allocator<std::pair<const int, int> > > >::value);
 217   }
 218
 219   /*
 220   template<class Key, class T, class Hash, class Allocator>
 221     unordered_map(initializer_list<pair<const Key, T>>, typename see
 222   below::size_type, Hash,
 223                   Allocator)
 224       -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
 225   */
 226
 227   /* Ambiguous
 228   {
 229     boost::unordered_map m({std::pair<int const, int>(1,2)}, 0, f,
 230   pair_allocator);
 231     static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
 232   boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
 233   int>>>>::value);
 234   }
 235   */
 236
 237   // unordered_multimap
 238
 239   {
 240     boost::unordered_multimap m(x.begin(), x.end());
 241     static_assert(
 242       std::is_same<decltype(m), boost::unordered_multimap<int, int> >::value);
 243   }
 244
 245   /* Ambiguous:
 246   {
 247     boost::unordered_multimap m(x.begin(), x.end(), 0, std::hash<int>());
 248     static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
 249   std::hash<int>>>::value);
 250   }
 251
 252   {
 253     boost::unordered_multimap m(x.begin(), x.end(), 0, std::hash<int>(),
 254   std::equal_to<int>());
 255     static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
 256   std::hash<int>, std::equal_to<int>>>::value);
 257   }
 258   */
 259
 260   {
 261     boost::unordered_multimap m(x.begin(), x.end(), 0, std::hash<int>(),
 262       std::equal_to<int>(), pair_allocator);
 263     static_assert(std::is_same<decltype(m),
 264       boost::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>,
 265         test_allocator<std::pair<const int, int> > > >::value);
 266   }
 267
 268   {
 269     boost::unordered_multimap m({std::pair<int const, int>(1, 2)});
 270     static_assert(
 271       std::is_same<decltype(m), boost::unordered_multimap<int, int> >::value);
 272   }
 273
 274   /* Ambiguous
 275   {
 276     boost::unordered_multimap m({std::pair<int const, int>(1,2)}, 0,
 277   std::hash<int>());
 278     static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
 279   std::hash<int>>>::value);
 280   }
 281
 282   {
 283     boost::unordered_multimap m({std::pair<int const, int>(1,2)}, 0,
 284   std::hash<int>(), std::equal_to<int>());
 285     static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
 286   std::hash<int>, std::equal_to<int>>>::value);
 287   }
 288   */
 289
 290   {
 291     boost::unordered_multimap m(
 292       {std::pair<int const, int>(1, 2)}, 0, f, f, pair_allocator);
 293     static_assert(std::is_same<decltype(m),
 294       boost::unordered_multimap<int, int, hash_equals, hash_equals,
 295         test_allocator<std::pair<const int, int> > > >::value);
 296   }
 297
 298   /* Ambiguous
 299   {
 300     boost::unordered_multimap m(x.begin(), x.end(), 0u, pair_allocator);
 301     static_assert(std::is_same<decltype(m), boost::unordered_multimap<int, int,
 302   boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
 303   int>>>>::value);
 304   }
 305   */
 306
 307   /* No constructor:
 308   {
 309     boost::unordered_multimap m(x.begin(), x.end(), pair_allocator);
 310     static_assert(std::is_same<decltype(m), boost::unordered_multimap<int, int,
 311   boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
 312   int>>>>::value);
 313   }
 314   */
 315
 316   /* Ambiguous
 317   {
 318     boost::unordered_multimap m(x.begin(), x.end(), 0u, f, pair_allocator);
 319     static_assert(std::is_same<decltype(m), boost::unordered_multimap<int, int,
 320   hash_equals, std::equal_to<int>, test_allocator<std::pair<const int,
 321   int>>>>::value);
 322   }
 323
 324   {
 325     boost::unordered_multimap m({std::pair<int const, int>(1,2)}, 0,
 326   pair_allocator);
 327     static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
 328   boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
 329   int>>>>::value);
 330   }
 331   */
 332
 333   {
 334     boost::unordered_multimap m(
 335       {std::pair<int const, int>(1, 2)}, pair_allocator);
 336     static_assert(std::is_same<decltype(m),
 337       boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
 338         test_allocator<std::pair<const int, int> > > >::value);
 339   }
 340
 341 /* Ambiguous
 342 {
 343   boost::unordered_multimap m({std::pair<int const, int>(1,2)}, 0, f,
 344 pair_allocator);
 345   static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
 346 boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
 347 int>>>>::value);
 348 }
 349 */
 350
 351 #endif
 352 }