-
Notifications
You must be signed in to change notification settings - Fork 606
/
SortedIterable.java
132 lines (110 loc) · 4.93 KB
/
SortedIterable.java
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
128
129
130
131
132
/*
* Copyright (c) 2017 Goldman Sachs and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.api.ordered;
import java.util.Comparator;
import java.util.NoSuchElementException;
import org.eclipse.collections.api.block.function.Function;
import org.eclipse.collections.api.block.predicate.Predicate;
import org.eclipse.collections.api.block.predicate.Predicate2;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.list.ListIterable;
import org.eclipse.collections.api.multimap.ordered.SortedIterableMultimap;
import org.eclipse.collections.api.partition.ordered.PartitionSortedIterable;
import org.eclipse.collections.api.stack.MutableStack;
import org.eclipse.collections.api.tuple.Pair;
/**
* A SortedIterable is an ordered iterable where the elements are stored in sorted order defined by a non-strict partial
* order relation. The sort order is determined by the Comparator returned by {@link #comparator()} or is the natural
* ordering if {@code comparator()} returns {@code null}. Operations that would sort the collection can be faster than
* O(n log n). For example {@link #toSortedList()} takes O(n) time.
*
* @since 5.0
*/
public interface SortedIterable<T> extends OrderedIterable<T>
{
/**
* Returns the comparator used to order the elements in this container, or null if this container uses the natural
* ordering of its elements.
*/
Comparator<? super T> comparator();
@Override
SortedIterable<T> tap(Procedure<? super T> procedure);
/**
* Returns the initial elements that satisfy the Predicate. Short circuits at the first element which does not
* satisfy the Predicate.
*/
@Override
SortedIterable<T> takeWhile(Predicate<? super T> predicate);
/**
* Returns the final elements that do not satisfy the Predicate. Short circuits at the first element which does
* satisfy the Predicate.
*/
@Override
SortedIterable<T> dropWhile(Predicate<? super T> predicate);
/**
* Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements. Short circuits at the first element which does
* satisfy the Predicate.
*/
@Override
PartitionSortedIterable<T> partitionWhile(Predicate<? super T> predicate);
/**
* Returns a new {@code SortedIterable} containing the distinct elements in this iterable.
* <p>
* Conceptually similar to {@link #toSet()}.{@link #toList()} but retains the original order. If an element appears
* multiple times in this iterable, the first one will be copied into the result.
*
* @return {@code SortedIterable} of distinct elements
*/
@Override
SortedIterable<T> distinct();
/**
* Converts the SortedIterable to a mutable MutableStack implementation.
*/
@Override
MutableStack<T> toStack();
/**
* Returns the minimum element out of this container based on the natural order, not the order of this container.
* If you want the minimum element based on the order of this container, use {@link #getFirst()}.
*
* @throws ClassCastException if the elements are not {@link Comparable}
* @throws NoSuchElementException if the SortedIterable is empty
*/
@Override
T min();
/**
* Returns the maximum element out of this container based on the natural order, not the order of this container.
* If you want the maximum element based on the order of this container, use {@link #getLast()}.
*
* @throws ClassCastException if the elements are not {@link Comparable}
* @throws NoSuchElementException if the SortedIterable is empty
*/
@Override
T max();
@Override
SortedIterable<T> select(Predicate<? super T> predicate);
@Override
<P> SortedIterable<T> selectWith(Predicate2<? super T, ? super P> predicate, P parameter);
@Override
SortedIterable<T> reject(Predicate<? super T> predicate);
@Override
<P> SortedIterable<T> rejectWith(Predicate2<? super T, ? super P> predicate, P parameter);
@Override
PartitionSortedIterable<T> partition(Predicate<? super T> predicate);
@Override
<S> SortedIterable<S> selectInstancesOf(Class<S> clazz);
@Override
<V> SortedIterableMultimap<V, T> groupBy(Function<? super T, ? extends V> function);
@Override
<V> SortedIterableMultimap<V, T> groupByEach(Function<? super T, ? extends Iterable<V>> function);
@Override
<S> ListIterable<Pair<T, S>> zip(Iterable<S> that);
@Override
SortedIterable<Pair<T, Integer>> zipWithIndex();
}