1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
/*
* This source code is released into the public domain.
*/
#ifndef LIBLFJAIL_WORDS_HH
#define LIBLFJAIL_WORDS_HH
#include <algorithm>
#include <ranges>
#include "ctype.hh"
#include "generator.hh"
namespace lfjail {
/*
* words: take a string-like object and split it into words using the given
* predicate. Empty values are discarded (i.e., repeated separators are
* ignored).
*
* words() returns std::strings, while wordsv() return std::string_views
* which refer to the original string.
*/
namespace detail {
template<typename R, typename Pred>
auto split(std::string_view text, Pred &&pred) -> std::generator<R>
{
auto pos = std::ranges::begin(text);
auto end = std::ranges::end(text);
for (;;) {
// Skip leading whitespace.
pos = std::find_if_not(pos, end, pred);
// If there's no string left, we're done.
if (pos == end)
break;
// Find the end of the next word.
auto split_pos = std::find_if(pos, end, pred);
// Yield this word.
co_yield R(pos, split_pos);
pos = split_pos;
}
}
template<typename ValueType,
std::ranges::viewable_range Range,
std::indirect_unary_predicate<std::ranges::iterator_t<Range>> Pred>
requires (std::ranges::contiguous_range<Range>)
struct words_view :
std::ranges::view_interface<words_view<ValueType, Range, Pred>>
{
words_view(auto &&base, auto &&pred)
: _base(std::forward<decltype(base)>(base))
, _pred(std::forward<decltype(pred)>(pred))
, _generator(detail::split<ValueType>(
std::string_view(_base), _pred))
{}
auto begin(this auto const &self) {
return self._generator.begin();
}
auto end(this auto const &self) {
return self._generator.end();
}
private:
Range _base;
Pred _pred;
mutable std::generator<ValueType> _generator;
};
template<typename R>
struct words_impl : std::ranges::range_adaptor_closure<words_impl<R>> {
template<std::ranges::range Range, typename Pred>
constexpr auto operator()(Range &&range, Pred &&pred) const {
return words_view<R, Range, Pred>(
std::forward<decltype(range)>(range),
std::forward<decltype(pred)>(pred));
}
};
} // namespace detail
template<std::ranges::range Range,
std::indirect_unary_predicate<std::ranges::iterator_t<Range>> Pred>
auto words(Range &&range, Pred &&pred)
requires (std::ranges::borrowed_range<Range>)
{
return detail::words_impl<std::string_view>{}(
std::forward<Range>(range),
std::forward<Pred>(pred));
}
template<std::ranges::range Range,
std::indirect_unary_predicate<std::ranges::iterator_t<Range>> Pred>
auto words(Range &&range, Pred &&pred)
requires (!std::ranges::borrowed_range<Range>)
{
return detail::words_impl<std::string>{}(
std::forward<Range>(range),
std::forward<Pred>(pred));
}
template<std::ranges::range Range>
auto words(Range &&range, std::ranges::range_value_t<Range> ch)
{
return words(std::forward<Range>(range),
[ch](auto c) { return c == ch; });
}
template<std::ranges::range Range>
auto words(Range &&range)
{
return words(std::forward<Range>(range), is_c_space);
}
} // namespace lfjail
#endif // LIBLFJAIL_WORDS_HH
|
