2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.openecomp.sdc.common.util;
23 import java.util.ArrayList;
24 import java.util.List;
25 import java.util.Spliterator;
26 import java.util.Spliterators.AbstractSpliterator;
27 import java.util.function.Consumer;
28 import java.util.function.Predicate;
29 import java.util.stream.Stream;
30 import java.util.stream.StreamSupport;
33 * Utility Class For Actions On Streams
37 public final class StreamUtils {
38 private StreamUtils() {
39 throw new UnsupportedOperationException();
43 * Breaks the stream when the predicate is not met.<br>
44 * Does not evaluate elements after the stream breaks.<br>
45 * This method evaluates the stream.<br>
51 public static <T> Stream<T> takeWhilePlusOneNoEval(Stream<T> stream, Predicate<T> predicate) {
52 List<T> results = new ArrayList<>();
53 Consumer<T> listAdder = results::add;
57 }).filter(e -> !predicate.test(e)).findFirst();
58 return results.stream();
61 public static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<T> predicate) {
62 return StreamSupport.stream(takeWhile(stream.spliterator(), predicate), false);
65 public static <T> Stream<T> takeWhilePlusOne(Stream<T> stream, Predicate<T> predicate) {
66 return StreamSupport.stream(takeWhile(stream.spliterator(), new StopAfterFailPredicate<>(predicate)), false);
69 private static <T> Spliterator<T> takeWhile(Spliterator<T> splitr, Predicate<T> predicate) {
70 return new MySplitIterator<>(splitr, predicate);
73 public static class MySplitIterator<T> extends AbstractSpliterator<T> implements Spliterator<T> {
74 private boolean stillGoing = true;
75 private Spliterator<T> innerItr;
76 private Predicate<T> innerPred;
78 private MySplitIterator(Spliterator<T> splitItr, Predicate<T> pred) {
79 super(splitItr.estimateSize(), 0);
85 public boolean tryAdvance(Consumer<? super T> action) {
86 boolean canAdvance = true;
88 stillGoing = innerItr.tryAdvance(createConsumerWrapper(action));
95 private Consumer<? super T> createConsumerWrapper(Consumer<? super T> action) {
97 return new Consumer<T>() {
99 public void accept(T t) {
100 stillGoing = innerPred.test(t);
111 public static class StopAfterFailPredicate<T> implements Predicate<T> {
112 private boolean hasNotFailed;
113 private Predicate<T> innerPredicate;
115 private StopAfterFailPredicate(Predicate<T> pred) {
117 innerPredicate = pred;
121 public boolean test(T t) {
125 hasNotFailed = innerPredicate.test(t);