afb81b8278
Some checks failed
Docker. / Ubuntu (push) Has been cancelled
User-agent updater. / User-agent (push) Failing after 15s
Lock Threads / lock (push) Failing after 10s
Waiting for answer. / waiting-for-answer (push) Failing after 22s
Needs user action. / needs-user-action (push) Failing after 8s
Can't reproduce. / cant-reproduce (push) Failing after 8s
Close stale issues and PRs / stale (push) Has been cancelled
342 lines
14 KiB
C++
342 lines
14 KiB
C++
// Range v3 library
|
|
//
|
|
// Copyright Eric Niebler 2014-present
|
|
// Copyright Google LLC 2020-present
|
|
//
|
|
// Use, modification and distribution is subject to 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)
|
|
//
|
|
// Project home: https://github.com/ericniebler/range-v3
|
|
|
|
//#define RANGES_USE_LEGACY_CONCEPTS 1
|
|
|
|
#include <sstream>
|
|
#include <vector>
|
|
#include <concepts/concepts.hpp>
|
|
#include <range/v3/iterator/concepts.hpp>
|
|
#include <range/v3/iterator/traits.hpp>
|
|
#include <range/v3/range/concepts.hpp>
|
|
#include <range/v3/range/traits.hpp>
|
|
#include <range/v3/view/istream.hpp>
|
|
#include <range/v3/iterator/common_iterator.hpp>
|
|
#include "../simple_test.hpp"
|
|
|
|
struct moveonly
|
|
{
|
|
moveonly(moveonly&&) = default;
|
|
moveonly& operator=(moveonly&&) = default;
|
|
};
|
|
|
|
struct nonmovable
|
|
{
|
|
nonmovable(nonmovable const &) = delete;
|
|
nonmovable& operator=(nonmovable const &) = delete;
|
|
};
|
|
|
|
struct nondefaultconstructible
|
|
{
|
|
nondefaultconstructible(int) {}
|
|
};
|
|
|
|
struct NotDestructible
|
|
{
|
|
~NotDestructible() = delete;
|
|
};
|
|
|
|
struct IntComparable
|
|
{
|
|
operator int() const;
|
|
|
|
friend bool operator==(IntComparable, IntComparable);
|
|
friend bool operator!=(IntComparable, IntComparable);
|
|
|
|
friend bool operator<(IntComparable, IntComparable);
|
|
friend bool operator>(IntComparable, IntComparable);
|
|
friend bool operator<=(IntComparable, IntComparable);
|
|
friend bool operator>=(IntComparable, IntComparable);
|
|
|
|
friend bool operator==(int, IntComparable);
|
|
friend bool operator!=(int, IntComparable);
|
|
friend bool operator==(IntComparable, int);
|
|
friend bool operator!=(IntComparable, int);
|
|
|
|
friend bool operator<(int, IntComparable);
|
|
friend bool operator<(IntComparable, int);
|
|
friend bool operator>(int, IntComparable);
|
|
friend bool operator>(IntComparable, int);
|
|
friend bool operator<=(int, IntComparable);
|
|
friend bool operator<=(IntComparable, int);
|
|
friend bool operator>=(int, IntComparable);
|
|
friend bool operator>=(IntComparable, int);
|
|
};
|
|
|
|
struct IntSwappable
|
|
{
|
|
operator int() const;
|
|
|
|
friend void swap(int &, IntSwappable);
|
|
friend void swap(IntSwappable, int &);
|
|
friend void swap(IntSwappable, IntSwappable);
|
|
};
|
|
|
|
static_assert(ranges::same_as<int, int>, "");
|
|
static_assert(ranges::same_as<void, void>, "");
|
|
static_assert(ranges::same_as<void const, void const>, "");
|
|
static_assert(!ranges::same_as<int&, int>, "");
|
|
static_assert(!ranges::same_as<void, void const>, "");
|
|
static_assert(!ranges::same_as<void(), void(*)()>, "");
|
|
|
|
static_assert(ranges::convertible_to<int, int>, "");
|
|
static_assert(ranges::convertible_to<short&, short const&>, "");
|
|
static_assert(ranges::convertible_to<int, short>, "");
|
|
static_assert(!ranges::convertible_to<int&, short&>, "");
|
|
static_assert(!ranges::convertible_to<int, void>, "");
|
|
static_assert(!ranges::convertible_to<int, int&>, "");
|
|
|
|
static_assert(ranges::unsigned_integral<unsigned>, "");
|
|
static_assert(!ranges::unsigned_integral<int>, "");
|
|
|
|
static_assert(ranges::assignable_from<int&, int>, "");
|
|
static_assert(!ranges::assignable_from<int const&, int>, "");
|
|
static_assert(!ranges::assignable_from<int, int>, "");
|
|
|
|
static_assert(ranges::destructible<int>, "");
|
|
static_assert(ranges::destructible<const int>, "");
|
|
static_assert(!ranges::destructible<void>, "");
|
|
static_assert(ranges::destructible<int&>, "");
|
|
static_assert(!ranges::destructible<void()>, "");
|
|
static_assert(ranges::destructible<void(*)()>, "");
|
|
static_assert(ranges::destructible<void(&)()>, "");
|
|
static_assert(!ranges::destructible<int[]>, "");
|
|
static_assert(ranges::destructible<int[2]>, "");
|
|
static_assert(ranges::destructible<int(*)[2]>, "");
|
|
static_assert(ranges::destructible<int(&)[2]>, "");
|
|
static_assert(ranges::destructible<moveonly>, "");
|
|
static_assert(ranges::destructible<nonmovable>, "");
|
|
static_assert(!ranges::destructible<NotDestructible>, "");
|
|
|
|
static_assert(ranges::constructible_from<int>, "");
|
|
static_assert(ranges::constructible_from<int const>, "");
|
|
static_assert(!ranges::constructible_from<void>, "");
|
|
static_assert(!ranges::constructible_from<int const &>, "");
|
|
static_assert(!ranges::constructible_from<int ()>, "");
|
|
static_assert(!ranges::constructible_from<int(&)()>, "");
|
|
static_assert(!ranges::constructible_from<int[]>, "");
|
|
static_assert(ranges::constructible_from<int[5]>, "");
|
|
static_assert(!ranges::constructible_from<nondefaultconstructible>, "");
|
|
static_assert(ranges::constructible_from<int const(&)[5], int(&)[5]>, "");
|
|
static_assert(!ranges::constructible_from<int, int(&)[3]>, "");
|
|
|
|
static_assert(ranges::constructible_from<int, int>, "");
|
|
static_assert(ranges::constructible_from<int, int&>, "");
|
|
static_assert(ranges::constructible_from<int, int&&>, "");
|
|
static_assert(ranges::constructible_from<int, const int>, "");
|
|
static_assert(ranges::constructible_from<int, const int&>, "");
|
|
static_assert(ranges::constructible_from<int, const int&&>, "");
|
|
|
|
static_assert(!ranges::constructible_from<int&, int>, "");
|
|
static_assert(ranges::constructible_from<int&, int&>, "");
|
|
static_assert(!ranges::constructible_from<int&, int&&>, "");
|
|
static_assert(!ranges::constructible_from<int&, const int>, "");
|
|
static_assert(!ranges::constructible_from<int&, const int&>, "");
|
|
static_assert(!ranges::constructible_from<int&, const int&&>, "");
|
|
|
|
static_assert(ranges::constructible_from<const int&, int>, "");
|
|
static_assert(ranges::constructible_from<const int&, int&>, "");
|
|
static_assert(ranges::constructible_from<const int&, int&&>, "");
|
|
static_assert(ranges::constructible_from<const int&, const int>, "");
|
|
static_assert(ranges::constructible_from<const int&, const int&>, "");
|
|
static_assert(ranges::constructible_from<const int&, const int&&>, "");
|
|
|
|
static_assert(ranges::constructible_from<int&&, int>, "");
|
|
static_assert(!ranges::constructible_from<int&&, int&>, "");
|
|
static_assert(ranges::constructible_from<int&&, int&&>, "");
|
|
static_assert(!ranges::constructible_from<int&&, const int>, "");
|
|
static_assert(!ranges::constructible_from<int&&, const int&>, "");
|
|
static_assert(!ranges::constructible_from<int&&, const int&&>, "");
|
|
|
|
static_assert(ranges::constructible_from<const int&&, int>, "");
|
|
static_assert(!ranges::constructible_from<const int&&, int&>, "");
|
|
static_assert(ranges::constructible_from<const int&&, int&&>, "");
|
|
static_assert(ranges::constructible_from<const int&&, const int>, "");
|
|
static_assert(!ranges::constructible_from<const int&&, const int&>, "");
|
|
static_assert(ranges::constructible_from<const int&&, const int&&>, "");
|
|
|
|
struct XXX
|
|
{
|
|
XXX() = default;
|
|
XXX(XXX&&) = delete;
|
|
explicit XXX(int) {}
|
|
};
|
|
|
|
static_assert(ranges::constructible_from<XXX, int>, "");
|
|
static_assert(!ranges::move_constructible<XXX>, "");
|
|
static_assert(!ranges::movable<XXX>, "");
|
|
static_assert(!ranges::semiregular<XXX>, "");
|
|
static_assert(!ranges::regular<XXX>, "");
|
|
|
|
static_assert(ranges::default_constructible<int>, "");
|
|
static_assert(ranges::default_constructible<int const>, "");
|
|
static_assert(!ranges::default_constructible<int const &>, "");
|
|
static_assert(!ranges::default_constructible<int ()>, "");
|
|
static_assert(!ranges::default_constructible<int(&)()>, "");
|
|
static_assert(!ranges::default_constructible<int[]>, "");
|
|
static_assert(ranges::default_constructible<int[5]>, "");
|
|
static_assert(!ranges::default_constructible<nondefaultconstructible>, "");
|
|
|
|
static_assert(ranges::move_constructible<int>, "");
|
|
static_assert(ranges::move_constructible<const int>, "");
|
|
static_assert(ranges::move_constructible<int &>, "");
|
|
static_assert(ranges::move_constructible<int &&>, "");
|
|
static_assert(ranges::move_constructible<const int &>, "");
|
|
static_assert(ranges::move_constructible<const int &&>, "");
|
|
static_assert(ranges::destructible<moveonly>, "");
|
|
static_assert(ranges::constructible_from<moveonly, moveonly>, "");
|
|
static_assert(ranges::move_constructible<moveonly>, "");
|
|
static_assert(!ranges::move_constructible<nonmovable>, "");
|
|
static_assert(ranges::move_constructible<nonmovable &>, "");
|
|
static_assert(ranges::move_constructible<nonmovable &&>, "");
|
|
static_assert(ranges::move_constructible<const nonmovable &>, "");
|
|
static_assert(ranges::move_constructible<const nonmovable &&>, "");
|
|
|
|
static_assert(ranges::copy_constructible<int>, "");
|
|
static_assert(ranges::copy_constructible<const int>, "");
|
|
static_assert(ranges::copy_constructible<int &>, "");
|
|
static_assert(!ranges::copy_constructible<int &&>, "");
|
|
static_assert(ranges::copy_constructible<const int &>, "");
|
|
static_assert(!ranges::copy_constructible<const int &&>, "");
|
|
static_assert(!ranges::copy_constructible<moveonly>, "");
|
|
static_assert(!ranges::copy_constructible<nonmovable>, "");
|
|
static_assert(ranges::copy_constructible<nonmovable &>, "");
|
|
static_assert(!ranges::copy_constructible<nonmovable &&>, "");
|
|
static_assert(ranges::copy_constructible<const nonmovable &>, "");
|
|
static_assert(!ranges::copy_constructible<const nonmovable &&>, "");
|
|
|
|
static_assert(ranges::movable<int>, "");
|
|
static_assert(!ranges::movable<int const>, "");
|
|
static_assert(ranges::movable<moveonly>, "");
|
|
static_assert(!ranges::movable<nonmovable>, "");
|
|
|
|
static_assert(ranges::copyable<int>, "");
|
|
static_assert(!ranges::copyable<int const>, "");
|
|
static_assert(!ranges::copyable<moveonly>, "");
|
|
static_assert(!ranges::copyable<nonmovable>, "");
|
|
|
|
// static_assert(ranges::predicate<std::less<int>, int, int>, "");
|
|
// static_assert(!ranges::predicate<std::less<int>, char*, int>, "");
|
|
|
|
static_assert(ranges::input_iterator<int*>, "");
|
|
static_assert(!ranges::input_iterator<int>, "");
|
|
|
|
static_assert(ranges::forward_iterator<int*>, "");
|
|
static_assert(!ranges::forward_iterator<int>, "");
|
|
|
|
static_assert(ranges::bidirectional_iterator<int*>, "");
|
|
static_assert(!ranges::bidirectional_iterator<int>, "");
|
|
|
|
static_assert(ranges::random_access_iterator<int*>, "");
|
|
static_assert(!ranges::random_access_iterator<int>, "");
|
|
|
|
static_assert(ranges::contiguous_iterator<int*>, "");
|
|
static_assert(!ranges::contiguous_iterator<int>, "");
|
|
|
|
static_assert(ranges::view_<ranges::istream_view<int>>, "");
|
|
static_assert(ranges::input_iterator<ranges::iterator_t<ranges::istream_view<int>>>, "");
|
|
static_assert(!ranges::view_<int>, "");
|
|
|
|
static_assert(ranges::common_range<std::vector<int> >, "");
|
|
static_assert(ranges::common_range<std::vector<int> &>, "");
|
|
static_assert(!ranges::view_<std::vector<int>>, "");
|
|
static_assert(!ranges::view_<std::vector<int> &>, "");
|
|
static_assert(ranges::random_access_iterator<ranges::iterator_t<std::vector<int> const &>>, "");
|
|
static_assert(!ranges::common_range<ranges::istream_view<int>>, "");
|
|
|
|
static_assert(ranges::predicate<std::less<int>, int, int>, "");
|
|
static_assert(!ranges::predicate<std::less<int>, char*, int>, "");
|
|
|
|
static_assert(ranges::output_iterator<int *, int>, "");
|
|
static_assert(!ranges::output_iterator<int const *, int>, "");
|
|
|
|
static_assert(ranges::swappable<int &>, "");
|
|
static_assert(ranges::swappable<int>, "");
|
|
static_assert(!ranges::swappable<int const &>, "");
|
|
static_assert(ranges::swappable<IntSwappable>, "");
|
|
static_assert(ranges::swappable_with<IntSwappable, int &>, "");
|
|
static_assert(!ranges::swappable_with<IntSwappable, int const &>, "");
|
|
|
|
static_assert(ranges::totally_ordered<int>, "");
|
|
static_assert(ranges::common_with<int, IntComparable>, "");
|
|
static_assert(ranges::common_reference_with<int &, IntComparable &>, "");
|
|
static_assert(ranges::totally_ordered_with<int, IntComparable>, "");
|
|
static_assert(ranges::totally_ordered_with<IntComparable, int>, "");
|
|
static_assert(ranges::detail::weakly_equality_comparable_with_<int, int>, "");
|
|
static_assert(ranges::equality_comparable<int>, "");
|
|
static_assert(ranges::equality_comparable_with<int, int>, "");
|
|
static_assert(ranges::equality_comparable_with<int, IntComparable>, "");
|
|
static_assert(ranges::equality_comparable_with<int &, IntComparable &>, "");
|
|
|
|
#if __cplusplus > 201703L && __has_include(<compare>) && \
|
|
defined(__cpp_concepts) && defined(__cpp_impl_three_way_comparison)
|
|
#include <compare>
|
|
|
|
static_assert(ranges::three_way_comparable<int>);
|
|
static_assert(ranges::three_way_comparable<int, std::partial_ordering>);
|
|
static_assert(ranges::three_way_comparable<int, std::weak_ordering>);
|
|
static_assert(ranges::three_way_comparable<int, std::strong_ordering>);
|
|
|
|
static_assert(ranges::three_way_comparable_with<int, IntComparable>);
|
|
static_assert(ranges::three_way_comparable_with<int, IntComparable, std::partial_ordering>);
|
|
static_assert(ranges::three_way_comparable_with<int, IntComparable, std::weak_ordering>);
|
|
static_assert(ranges::three_way_comparable_with<int, IntComparable, std::strong_ordering>);
|
|
static_assert(ranges::three_way_comparable_with<IntComparable, int>);
|
|
static_assert(ranges::three_way_comparable_with<IntComparable, int, std::partial_ordering>);
|
|
static_assert(ranges::three_way_comparable_with<IntComparable, int, std::weak_ordering>);
|
|
static_assert(ranges::three_way_comparable_with<IntComparable, int, std::strong_ordering>);
|
|
#endif // supports spaceship
|
|
|
|
static_assert(
|
|
std::is_same<
|
|
ranges::common_range_tag_of<std::vector<int>>,
|
|
ranges::common_range_tag
|
|
>::value, "");
|
|
|
|
static_assert(
|
|
std::is_same<
|
|
ranges::sized_range_tag_of<std::vector<int>>,
|
|
ranges::sized_range_tag
|
|
>::value, "");
|
|
|
|
static_assert(ranges::view_<ranges::istream_view<int>>, "");
|
|
static_assert(!ranges::common_range<ranges::istream_view<int>>, "");
|
|
static_assert(!ranges::sized_range<ranges::istream_view<int>>, "");
|
|
|
|
struct myview : ranges::view_base {
|
|
const char *begin();
|
|
const char *end();
|
|
};
|
|
CPP_assert(ranges::view_<myview>);
|
|
|
|
CPP_template(class T)
|
|
(requires ranges::regular<T>)
|
|
constexpr bool is_regular(T&&)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
CPP_template(class T)
|
|
(requires (!ranges::regular<T>))
|
|
constexpr bool is_regular(T&&)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static_assert(is_regular(42), "");
|
|
static_assert(!is_regular(XXX{}), "");
|
|
|
|
int main()
|
|
{
|
|
return test_result();
|
|
}
|