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
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
struct PredicateConsumer<Consumed: Collection> {
let predicate: (Consumed.Element) -> Bool
}
extension PredicateConsumer: CollectionConsumer {
public func consuming(
_ consumed: Consumed,
in range: Range<Consumed.Index>
) -> Consumed.Index? {
let start = range.lowerBound
guard start != range.upperBound && predicate(consumed[start]) else {
return nil
}
return consumed.index(after: start)
}
}
extension PredicateConsumer: BidirectionalCollectionConsumer
where Consumed: BidirectionalCollection
{
func consumingBack(
_ consumed: Consumed,
in range: Range<Consumed.Index>
) -> Consumed.Index? {
let end = range.upperBound
guard end != range.lowerBound else { return nil }
let previous = consumed.index(before: end)
return predicate(consumed[previous]) ? previous : nil
}
}
extension PredicateConsumer: StatelessCollectionSearcher {
public typealias Searched = Consumed
public func search(
_ searched: Searched,
in range: Range<Searched.Index>
) -> Range<Searched.Index>? {
// TODO: Make this reusable
guard let index = searched[range].firstIndex(where: predicate) else {
return nil
}
return index..<searched.index(after: index)
}
}
extension PredicateConsumer: BackwardCollectionSearcher,
BackwardStatelessCollectionSearcher
where Searched: BidirectionalCollection
{
typealias BackwardSearched = Consumed
func searchBack(
_ searched: BackwardSearched,
in range: Range<BackwardSearched.Index>
) -> Range<BackwardSearched.Index>? {
// TODO: Make this reusable
guard let index = searched[range].lastIndex(where: predicate) else {
return nil
}
return index..<searched.index(after: index)
}
}
|
