ceph/src/boost/libs/stl_interfaces/test/input.cpp

   1 // Copyright (C) 2019 T. Zachary Laine
   2 //
   3 // Distributed under the Boost Software License, Version 1.0. (See
   4 // accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6 #include <boost/stl_interfaces/iterator_interface.hpp>
   7
   8 #include "ill_formed.hpp"
   9
  10 #include <boost/core/lightweight_test.hpp>
  11
  12 #include <array>
  13 #include <numeric>
  14 #include <type_traits>
  15
  16
  17 struct basic_input_iter
  18     : boost::stl_interfaces::
  19           iterator_interface<basic_input_iter, std::input_iterator_tag, int>
  20 {
  21     basic_input_iter() : it_(nullptr) {}
  22     basic_input_iter(int * it) : it_(it) {}
  23
  24     int & operator*() const noexcept { return *it_; }
  25     basic_input_iter & operator++() noexcept
  26     {
  27         ++it_;
  28         return *this;
  29     }
  30     friend bool operator==(basic_input_iter lhs, basic_input_iter rhs) noexcept
  31     {
  32         return lhs.it_ == rhs.it_;
  33     }
  34
  35     using base_type = boost::stl_interfaces::
  36         iterator_interface<basic_input_iter, std::input_iterator_tag, int>;
  37     using base_type::operator++;
  38
  39 private:
  40     int * it_;
  41 };
  42
  43 BOOST_STL_INTERFACES_STATIC_ASSERT_CONCEPT(
  44     basic_input_iter, std::input_iterator)
  45 BOOST_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(
  46     basic_input_iter,
  47     std::input_iterator_tag,
  48     std::input_iterator_tag,
  49     int,
  50     int &,
  51     int *,
  52     std::ptrdiff_t)
  53
  54 template<typename ValueType>
  55 struct input_iter : boost::stl_interfaces::iterator_interface<
  56                         input_iter<ValueType>,
  57                         std::input_iterator_tag,
  58                         ValueType>
  59 {
  60     input_iter() : it_(nullptr) {}
  61     input_iter(ValueType * it) : it_(it) {}
  62     template<
  63         typename ValueType2,
  64         typename E = std::enable_if_t<
  65             std::is_convertible<ValueType2 *, ValueType *>::value>>
  66     input_iter(input_iter<ValueType2> it) : it_(it.it_)
  67     {}
  68
  69     ValueType & operator*() const noexcept { return *it_; }
  70     input_iter & operator++() noexcept
  71     {
  72         ++it_;
  73         return *this;
  74     }
  75     friend bool operator==(input_iter lhs, input_iter rhs) noexcept
  76     {
  77         return lhs.it_ == rhs.it_;
  78     }
  79
  80     using base_type = boost::stl_interfaces::iterator_interface<
  81         input_iter<ValueType>,
  82         std::input_iterator_tag,
  83         ValueType>;
  84     using base_type::operator++;
  85
  86 private:
  87     ValueType * it_;
  88
  89     template<typename ValueType2>
  90     friend struct input_iter;
  91 };
  92
  93 BOOST_STL_INTERFACES_STATIC_ASSERT_CONCEPT(input_iter<int>, std::input_iterator)
  94 BOOST_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(
  95     input_iter<int>,
  96     std::input_iterator_tag,
  97     std::input_iterator_tag,
  98     int,
  99     int &,
 100     int *,
 101     std::ptrdiff_t)
 102
 103 using int_input = input_iter<int>;
 104 using const_int_input = input_iter<int const>;
 105 using pair_input = input_iter<std::pair<int, int>>;
 106 using const_pair_input = input_iter<std::pair<int, int> const>;
 107
 108 template<typename ValueType>
 109 struct proxy_input_iter : boost::stl_interfaces::proxy_iterator_interface<
 110                               proxy_input_iter<ValueType>,
 111                               std::input_iterator_tag,
 112                               ValueType>
 113 {
 114     proxy_input_iter() : it_(nullptr) {}
 115     proxy_input_iter(ValueType * it) : it_(it) {}
 116     template<
 117         typename ValueType2,
 118         typename E = std::enable_if_t<
 119             std::is_convertible<ValueType2 *, ValueType *>::value>>
 120     proxy_input_iter(proxy_input_iter<ValueType2> it) : it_(it.it_)
 121     {}
 122
 123     ValueType operator*() const noexcept { return *it_; }
 124     proxy_input_iter & operator++() noexcept
 125     {
 126         ++it_;
 127         return *this;
 128     }
 129     friend bool operator==(proxy_input_iter lhs, proxy_input_iter rhs) noexcept
 130     {
 131         return lhs.it_ == rhs.it_;
 132     }
 133
 134     using base_type = boost::stl_interfaces::proxy_iterator_interface<
 135         proxy_input_iter<ValueType>,
 136         std::input_iterator_tag,
 137         ValueType>;
 138     using base_type::operator++;
 139
 140 private:
 141     ValueType * it_;
 142
 143     template<typename ValueType2>
 144     friend struct proxy_input_iter;
 145 };
 146
 147 using int_pair = std::pair<int, int>;
 148 BOOST_STL_INTERFACES_STATIC_ASSERT_CONCEPT(
 149     proxy_input_iter<int_pair>, std::input_iterator)
 150 BOOST_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(
 151     proxy_input_iter<int_pair>,
 152     std::input_iterator_tag,
 153     std::input_iterator_tag,
 154     int_pair,
 155     int_pair,
 156     boost::stl_interfaces::proxy_arrow_result<int_pair>,
 157     std::ptrdiff_t)
 158
 159 std::array<int, 10> ints = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}};
 160 std::array<std::pair<int, int>, 10> pairs = {{
 161     {0, 1},
 162     {1, 1},
 163     {2, 1},
 164     {3, 1},
 165     {4, 1},
 166     {5, 1},
 167     {6, 1},
 168     {7, 1},
 169     {8, 1},
 170     {9, 1},
 171 }};
 172
 173
 174 ////////////////////
 175 // view_interface //
 176 ////////////////////
 177 #include "view_tests.hpp"
 178
 179 template<typename T>
 180 using data_t = decltype(std::declval<T>().data());
 181
 182 static_assert(
 183     ill_formed<
 184         data_t,
 185         subrange<
 186             basic_input_iter,
 187             basic_input_iter,
 188             boost::stl_interfaces::v1::element_layout::discontiguous>>::value,
 189     "");
 190 static_assert(
 191     ill_formed<
 192         data_t,
 193         subrange<
 194             basic_input_iter,
 195             basic_input_iter,
 196             boost::stl_interfaces::v1::element_layout::discontiguous> const>::
 197         value,
 198     "");
 199
 200 template<typename T>
 201 using size_t_ = decltype(std::declval<T>().size());
 202
 203 static_assert(
 204     ill_formed<
 205         size_t_,
 206         subrange<
 207             basic_input_iter,
 208             basic_input_iter,
 209             boost::stl_interfaces::v1::element_layout::discontiguous>>::value,
 210     "");
 211 static_assert(
 212     ill_formed<
 213         size_t_,
 214         subrange<
 215             basic_input_iter,
 216             basic_input_iter,
 217             boost::stl_interfaces::v1::element_layout::discontiguous> const>::
 218         value,
 219     "");
 220
 221 template<typename T>
 222 using back_t_ = decltype(std::declval<T>().back());
 223
 224 static_assert(
 225     ill_formed<
 226         back_t_,
 227         subrange<
 228             basic_input_iter,
 229             basic_input_iter,
 230             boost::stl_interfaces::v1::element_layout::discontiguous>>::value,
 231     "");
 232 static_assert(
 233     ill_formed<
 234         back_t_,
 235         subrange<
 236             basic_input_iter,
 237             basic_input_iter,
 238             boost::stl_interfaces::v1::element_layout::discontiguous> const>::
 239         value,
 240     "");
 241
 242 template<typename T>
 243 using index_operator_t = decltype(std::declval<T>()[0]);
 244
 245 static_assert(
 246     ill_formed<
 247         index_operator_t,
 248         subrange<
 249             basic_input_iter,
 250             basic_input_iter,
 251             boost::stl_interfaces::v1::element_layout::discontiguous>>::value,
 252     "");
 253 static_assert(
 254     ill_formed<
 255         index_operator_t,
 256         subrange<
 257             basic_input_iter,
 258             basic_input_iter,
 259             boost::stl_interfaces::v1::element_layout::discontiguous> const>::
 260         value,
 261     "");
 262
 263
 264 int main()
 265 {
 266
 267 {
 268     basic_input_iter first(ints.data());
 269     basic_input_iter last(ints.data() + ints.size());
 270
 271     {
 272         std::array<int, 10> ints_copy;
 273         std::copy(first, last, ints_copy.begin());
 274         BOOST_TEST(ints_copy == ints);
 275     }
 276 }
 277
 278
 279 {
 280     int_input first(ints.data());
 281     int_input last(ints.data() + ints.size());
 282     const_int_input first_copy(first);
 283     const_int_input last_copy(last);
 284     std::equal(first, last, first_copy, last_copy);
 285 }
 286
 287
 288 {
 289     int_input first(ints.data());
 290     int_input last(ints.data() + ints.size());
 291     while (first != last)
 292         first++;
 293 }
 294
 295
 296 {
 297     {
 298         std::array<int, 10> ints_copy;
 299         int_input first(ints.data());
 300         int_input last(ints.data() + ints.size());
 301         std::copy(first, last, ints_copy.begin());
 302         BOOST_TEST(ints_copy == ints);
 303     }
 304
 305     {
 306         std::array<std::pair<int, int>, 10> pairs_copy;
 307         pair_input first(pairs.data());
 308         pair_input last(pairs.data() + pairs.size());
 309         std::copy(first, last, pairs_copy.begin());
 310         BOOST_TEST(pairs_copy == pairs);
 311     }
 312
 313     {
 314         std::array<int, 10> firsts_copy;
 315         pair_input first(pairs.data());
 316         pair_input last(pairs.data() + pairs.size());
 317         for (auto out = firsts_copy.begin(); first != last; ++first) {
 318             *out++ = first->first;
 319         }
 320         BOOST_TEST(firsts_copy == ints);
 321     }
 322
 323     {
 324         std::array<int, 10> firsts_copy;
 325         proxy_input_iter<std::pair<int, int>> first(pairs.data());
 326         proxy_input_iter<std::pair<int, int>> last(pairs.data() + pairs.size());
 327         for (auto out = firsts_copy.begin(); first != last; ++first) {
 328             *out++ = first->first;
 329         }
 330         BOOST_TEST(firsts_copy == ints);
 331     }
 332 }
 333
 334
 335 {
 336     {
 337         std::array<int, 10> ints_copy;
 338         const_int_input first(ints.data());
 339         const_int_input last(ints.data() + ints.size());
 340         std::copy(first, last, ints_copy.begin());
 341         BOOST_TEST(ints_copy == ints);
 342     }
 343
 344     {
 345         std::array<std::pair<int, int>, 10> pairs_copy;
 346         const_pair_input first(pairs.data());
 347         const_pair_input last(pairs.data() + pairs.size());
 348         std::copy(first, last, pairs_copy.begin());
 349         BOOST_TEST(pairs_copy == pairs);
 350     }
 351
 352     {
 353         std::array<int, 10> firsts_copy;
 354         const_pair_input first(pairs.data());
 355         const_pair_input last(pairs.data() + pairs.size());
 356         for (auto out = firsts_copy.begin(); first != last; ++first) {
 357             *out++ = first->first;
 358         }
 359         BOOST_TEST(firsts_copy == ints);
 360     }
 361
 362     {
 363         std::array<int, 10> firsts_copy;
 364         proxy_input_iter<std::pair<int, int> const> first(pairs.data());
 365         proxy_input_iter<std::pair<int, int> const> last(
 366             pairs.data() + pairs.size());
 367         for (auto out = firsts_copy.begin(); first != last; ++first) {
 368             *out++ = first->first;
 369         }
 370         BOOST_TEST(firsts_copy == ints);
 371     }
 372 }
 373
 374 {
 375     basic_input_iter first(ints.data());
 376     basic_input_iter last(ints.data() + ints.size());
 377
 378     auto r = range<boost::stl_interfaces::v1::element_layout::discontiguous>(
 379         first, last);
 380     auto empty =
 381         range<boost::stl_interfaces::v1::element_layout::discontiguous>(
 382             first, first);
 383
 384     // range begin/end
 385     {
 386         std::array<int, 10> ints_copy;
 387         std::copy(r.begin(), r.end(), ints_copy.begin());
 388         BOOST_TEST(ints_copy == ints);
 389
 390         BOOST_TEST(empty.begin() == empty.end());
 391     }
 392
 393     // empty/op bool
 394     {
 395         BOOST_TEST(!r.empty());
 396         BOOST_TEST(r);
 397
 398         BOOST_TEST(empty.empty());
 399         BOOST_TEST(!empty);
 400
 401         auto const cr = r;
 402         BOOST_TEST(!cr.empty());
 403         BOOST_TEST(cr);
 404
 405         auto const cempty = empty;
 406         BOOST_TEST(cempty.empty());
 407         BOOST_TEST(!cempty);
 408     }
 409
 410     // front/back
 411     {
 412         BOOST_TEST(r.front() == 0);
 413
 414         auto const cr = r;
 415         BOOST_TEST(cr.front() == 0);
 416     }
 417 }
 418
 419     return boost::report_errors();
 420 }