@Override
public Tuple2<Vector<T>, Vector<T>> partition(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
final java.util.List<T> left = new ArrayList<>(), right = new ArrayList<>();
for (int i = 0; i < length(); i++) {
T t = get(i);
(predicate.test(t) ? left : right).add(t);
}
return Tuple.of(Vector.ofAll(left), Vector.ofAll(right));
}
@Test
public void testNotNull() throws Exception {
Predicate<Object> notNull = Predicates.notNull();
assertTrue(notNull.test("Hallo"));
assertFalse(notNull.test(null));
}
@Test
public void testIsNull() throws Exception {
Predicate<Object> isNull = Predicates.isNull();
assertTrue(isNull.test(null));
assertFalse(isNull.test("test"));
}
@Test
public void testAlwaysFalse() {
Predicate<Object> alwaysFalse = Predicates.alwaysFalse();
assertFalse(alwaysFalse.test(null));
assertFalse(alwaysFalse.test("FooBar"));
assertFalse(alwaysFalse.test(66d));
}
@Test
public void testAlwaysTrue() {
Predicate<Object> alwaysTrue = Predicates.alwaysTrue();
assertTrue(alwaysTrue.test(null));
assertTrue(alwaysTrue.test("Hallo"));
assertTrue(alwaysTrue.test(55l));
}
private void lookAhead() {
continue_ = iter_.hasNext();
if (!continue_) return;
next_ = iter_.next();
continue_ = pred_.test(next_);
} // lookAhead
@Override
public Tuple2<Array<T>, Array<T>> partition(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
final java.util.List<T> left = new ArrayList<>(), right = new ArrayList<>();
for (T t : this) {
(predicate.test(t) ? left : right).add(t);
}
return Tuple.of(ofAll(left), ofAll(right));
}
public static <T> List<T> filter(List<T> ls, Predicate<T> p) {
List<T> result = new ArrayList<T>();
for (T e : ls) {
if (p.test(e)) {
result.add(e);
}
}
return result;
}
@Override
public Array<T> dropWhile(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
for (int i = 0; i < length(); i++) {
if (!predicate.test(get(i))) {
return drop(i);
}
}
return empty();
}
@Override
public Map<String, String> getProperties() {
final Map<String, String> result = new HashMap<>();
for (Map.Entry<String, String> en : this.baseSource.getProperties().entrySet()) {
if (filter.test(en.getKey())) {
result.put(en.getKey(), en.getValue());
}
}
return result;
}
@Override
public Vector<T> removeLast(Predicate<T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
HashArrayMappedTrie<Integer, T> trie = HashArrayMappedTrie.empty();
for (int i = length() - 1; i >= 0; i--) {
if (predicate.test(get(i))) {
return removeAt(i);
}
}
return this;
}
@Override
public Array<T> takeWhile(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
for (int i = 0; i < length(); i++) {
final T value = get(i);
if (!predicate.test(value)) {
return take(i);
}
}
return this;
}
/**
* Matches a RED block in the RED payload.
*
* @param predicate the predicate that is used to match the RED block.
* @param buffer the byte buffer that contains the RED payload.
* @param offset the offset in the buffer where the RED payload begins.
* @param length the length of the RED payload.
* @return the first RED block that matches the given predicate, null otherwise.
*/
public static REDBlock matchFirst(
Predicate<REDBlock> predicate, byte[] buffer, int offset, int length) {
if (isMultiBlock(buffer, offset, length)) {
REDBlockIterator it = new REDBlockIterator(buffer, offset, length);
while (it.hasNext()) {
REDBlock b = it.next();
if (b != null && predicate.test(b)) {
return b;
}
}
return null;
} else {
REDBlock b = getPrimaryBlock(buffer, offset, length);
if (b != null && predicate.test(b)) {
return b;
} else {
return null;
}
}
}
@Override
public Vector<T> takeWhile(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
HashArrayMappedTrie<Integer, T> trie = HashArrayMappedTrie.empty();
for (int i = 0; i < length(); i++) {
T value = get(i);
if (!predicate.test(value)) {
break;
}
trie = trie.put(i, get(i));
}
return trie.size() == length() ? this : trie.isEmpty() ? empty() : new Vector<>(trie);
}
public static <TYPE> void await(
Supplier<TYPE> supplier, Predicate<TYPE> predicate, long timeout, TimeUnit unit)
throws TimeoutException, InterruptedException {
long sleep = Math.max(unit.toMillis(timeout) / 100, 1);
long deadline = System.currentTimeMillis() + unit.toMillis(timeout);
do {
if (predicate.test(supplier.get())) {
return;
}
Thread.sleep(sleep);
} while (System.currentTimeMillis() < deadline);
throw new TimeoutException(
"Waited for " + timeout + " " + unit + ", but " + predicate + " was not accepted.");
}
@Override
public Vector<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
HashArrayMappedTrie<Integer, T> trie = HashArrayMappedTrie.empty();
for (T t : this) {
if (predicate.test(t)) {
trie = trie.put(trie.size(), t);
}
}
if (trie.size() == length()) {
return this;
} else {
return trie.isEmpty() ? empty() : new Vector<>(trie);
}
}
@Override
public Tuple2<Array<T>, Array<T>> splitAtInclusive(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
for (int i = 0; i < length(); i++) {
final T value = get(i);
if (predicate.test(value)) {
if (i == length() - 1) {
return Tuple.of(this, empty());
} else {
return Tuple.of(take(i + 1), drop(i + 1));
}
}
}
return Tuple.of(this, empty());
}
@Override
public Tuple2<Vector<T>, Vector<T>> splitAtInclusive(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
HashArrayMappedTrie<Integer, T> init = HashArrayMappedTrie.empty();
for (T t : this) {
init = init.put(init.size(), t);
if (predicate.test(t)) {
if (init.size() == length()) {
Tuple.of(this, empty());
} else {
return Tuple.of(new Vector<>(init), drop(init.size()));
}
}
}
return Tuple.of(this, empty());
}
@Override
public Array<T> removeLast(Predicate<T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
int found = -1;
for (int i = length() - 1; i >= 0; i--) {
final T value = get(i);
if (predicate.test(value)) {
found = i;
break;
}
}
if (found < 0) {
return this;
} else {
return removeAt(found);
}
}
@Override
public Array<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
final java.util.List<T> list = new ArrayList<>();
for (T t : this) {
if (predicate.test(t)) {
list.add(t);
}
}
if (list.isEmpty()) {
return empty();
} else if (list.size() == size()) {
return this;
} else {
return wrap(list.toArray());
}
}
@Override
public Vector<T> removeFirst(Predicate<T> predicate) {
Objects.requireNonNull(predicate, "predicate is null");
HashArrayMappedTrie<Integer, T> trie = HashArrayMappedTrie.empty();
boolean found = false;
for (int i = 0; i < length(); i++) {
final T value = get(i);
if (found) {
trie = trie.put(trie.size(), value);
} else {
if (predicate.test(value)) {
found = true;
} else {
trie = trie.put(trie.size(), value);
}
}
}
return trie.size() == length() ? this : trie.isEmpty() ? empty() : new Vector<>(trie);
}
@Override
public FeatureExpr when(Predicate<T> condition) {
return condition.test(value) ? FeatureExprFactory.True() : FeatureExprFactory.False();
}
public void testEvaluateEqualsWithInteger() throws Exception {
Predicate predicate =
new LessThanOrEqualPredicate(
new LiteralExpression(Integer.valueOf(42)), new LiteralExpression(Integer.valueOf(42)));
assertTrue(predicate.test(null));
}
@Override
public FeatureExpr when(@Nonnull Predicate<T> condition) {
assert condition != null;
return condition.test(value) ? FeatureExprFactory.True() : FeatureExprFactory.False();
}
public void testEvaluateEquals() throws Exception {
Predicate predicate =
new LessThanOrEqualPredicate(
new LiteralExpression("Aaaaaa"), new LiteralExpression("Aaaaaa"));
assertTrue(predicate.test(null));
}
public List<Answer> classicFind(Predicate<Answer> pred) {
List<Answer> results = new ArrayList<Answer>();
for (Answer answer : answers.values()) if (pred.test(answer)) results.add(answer);
return results;
}