94461822c7
`subrange` is also a `tuple-like`. To avoid the add entire `subrange` dependencies to `tuple-like`, we need forward declaration of `subrange`. However, the class template constraints of `subrange` currently requires `__iterator/concepts.h`, which requires `<concepts>`. The problem is that currently `tuple-like` is used in several different places, including libc++ extension for pair constructors. we don't want to add `<concepts>` to pair and other stuff. So this change also created several small headers that `subrange`'s declaration needed inside `__iterator/concepts/` Differential Revision: https://reviews.llvm.org/D136268
104 lines
3.4 KiB
C++
104 lines
3.4 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
|
|
|
// Some basic examples of how elements_view might be used in the wild. This is a general
|
|
// collection of sample algorithms and functions that try to mock general usage of
|
|
// this view.
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cassert>
|
|
#include <map>
|
|
#include <ranges>
|
|
#include <string_view>
|
|
#include <tuple>
|
|
#include <utility>
|
|
|
|
#include "test_iterators.h"
|
|
|
|
int main(int, char**) {
|
|
using namespace std::string_view_literals;
|
|
auto historicalFigures =
|
|
std::map{std::pair{"Lovelace"sv, 1815}, {"Turing"sv, 1912}, {"Babbage"sv, 1791}, {"Hamilton"sv, 1936}};
|
|
auto expectedYears = {1791, 1936, 1815, 1912};
|
|
|
|
// views::elements<N>
|
|
{
|
|
auto names = historicalFigures | std::views::elements<0>;
|
|
auto expectedNames = {"Babbage"sv, "Hamilton"sv, "Lovelace"sv, "Turing"sv};
|
|
assert(std::ranges::equal(names, expectedNames));
|
|
|
|
auto birth_years = historicalFigures | std::views::elements<1>;
|
|
assert(std::ranges::equal(birth_years, expectedYears));
|
|
}
|
|
|
|
// views::keys
|
|
{
|
|
auto names = historicalFigures | std::views::keys;
|
|
auto expectedNames = {"Babbage"sv, "Hamilton"sv, "Lovelace"sv, "Turing"sv};
|
|
assert(std::ranges::equal(names, expectedNames));
|
|
}
|
|
|
|
// views::values
|
|
{
|
|
auto is_even = [](const auto x) { return x % 2 == 0; };
|
|
assert(std::ranges::count_if(historicalFigures | std::views::values, is_even) == 2);
|
|
}
|
|
|
|
// array
|
|
{
|
|
std::array<int, 3> arrs[] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
|
|
auto ev = arrs | std::views::elements<2>;
|
|
auto expected = {3, 6, 9};
|
|
assert(std::ranges::equal(ev, expected));
|
|
}
|
|
|
|
// pair
|
|
{
|
|
std::pair<double, int> ps[] = {{1.0, 2}, {3.0, 4}, {5.0, 6}};
|
|
auto ev = ps | std::views::elements<1>;
|
|
auto expected = {2, 4, 6};
|
|
assert(std::ranges::equal(ev, expected));
|
|
}
|
|
|
|
// tuple
|
|
{
|
|
std::tuple<short> tps[] = {{1}, {2}, {3}};
|
|
auto ev = tps | std::views::elements<0>;
|
|
auto expected = {1, 2, 3};
|
|
assert(std::ranges::equal(ev, expected));
|
|
}
|
|
|
|
// subrange
|
|
{
|
|
int is[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
|
using Iter = forward_iterator<int*>;
|
|
using Sent = sentinel_wrapper<Iter>;
|
|
using SubRange = std::ranges::subrange<Iter, Sent>;
|
|
SubRange sr[] = {
|
|
{Iter{is}, Sent{Iter{is + 1}}},
|
|
{Iter{is + 2}, Sent{Iter{is + 5}}},
|
|
{Iter{is + 6}, Sent{Iter{is + 8}}},
|
|
};
|
|
|
|
auto iters = sr | std::views::elements<0>;
|
|
static_assert(std::is_same_v<Iter, std::ranges::range_reference_t<decltype(iters)>>);
|
|
auto expectedIters = {is, is + 2, is + 6};
|
|
assert(std::ranges::equal(iters | std::views::transform([](auto&& iter) { return base(iter); }), expectedIters));
|
|
|
|
auto sentinels = sr | std::views::elements<1>;
|
|
static_assert(std::is_same_v<Sent, std::ranges::range_reference_t<decltype(sentinels)>>);
|
|
auto expectedSentinels = {is + 1, is + 5, is + 8};
|
|
assert(std::ranges::equal(
|
|
sentinels | std::views::transform([](auto&& st) { return base(base(st)); }), expectedSentinels));
|
|
}
|
|
return 0;
|
|
}
|