Example usage for java.util.stream Stream allMatch

Introduction

In this page you can find the example usage for java.util.stream Stream allMatch.

Prototype

boolean allMatch(Predicate<? super T> predicate);

Source Link

Document

Returns whether all elements of this stream match the provided predicate.

Usage

From source file:fr.landel.utils.assertor.helper.HelperAssertor.java

public static <T> boolean isValid(final Stream<T> stream, final Predicate<T> predicate, final boolean all,
        final boolean not, final Supplier<Integer> size) {
    if (all && !not) { // ALL
        return stream.allMatch(predicate);
    } else if (!all && !not) { // ANY
        return stream.anyMatch(predicate);
    } else if (!all) { // NOT ANY
        return stream.noneMatch(predicate);
    } else { // NOT ALL
        return isValid(all, not, stream.filter(predicate).count(), size.get());
    }/*from w w w. j a v  a 2s  . c  om*/
}

---

From source file:fr.landel.utils.assertor.utils.AssertorIterable.java

private static <I extends Iterable<T>, T> boolean has(final I iterable, final Predicate<T> predicate,
        final boolean all, final EnumAnalysisMode analysisMode) {
    if (EnumAnalysisMode.STANDARD.equals(analysisMode)) {
        if (all) {
            for (final T object : iterable) {
                if (!predicate.test(object)) {
                    return false;
                }//  w ww .j a  v  a2s . c  o  m
            }
            return true;
        } else {
            for (final T object : iterable) {
                if (predicate.test(object)) {
                    return true;
                }
            }
            return false;
        }
    } else {
        final Stream<T> stream = StreamSupport.stream(iterable.spliterator(),
                EnumAnalysisMode.PARALLEL.equals(analysisMode));
        if (all) {
            return stream.allMatch(predicate);
        } else {
            return stream.anyMatch(predicate);
        }
    }
}

---

From source file:fr.landel.utils.assertor.utils.AssertorMap.java

private static <K, V> boolean match(final Map<K, V> map, final Predicate<Entry<K, V>> predicate,
        final boolean all, final EnumAnalysisMode analysisMode) {

    final Set<Entry<K, V>> entries = map.entrySet();

    if (EnumAnalysisMode.STANDARD.equals(analysisMode)) {
        if (all) {
            for (final Entry<K, V> entry : entries) {
                if (!predicate.test(entry)) {
                    return false;
                }//w  ww .ja  v a  2  s . com
            }
            return true;
        } else {
            for (final Entry<K, V> entry : entries) {
                if (predicate.test(entry)) {
                    return true;
                }
            }
            return false;
        }
    } else {
        final Stream<Entry<K, V>> stream;
        if (EnumAnalysisMode.PARALLEL.equals(analysisMode)) {
            stream = entries.parallelStream();
        } else {
            stream = entries.stream();
        }
        if (all) {
            return stream.allMatch(predicate);
        } else {
            return stream.anyMatch(predicate);
        }
    }
}

---

From source file:de.fosd.jdime.matcher.cost_model.CostModelMatcher.java

/**
 * Bounds the ordering violation cost of <code>matching</code>.
 *
 * @param matching/*from w  w  w  . j av  a2  s .co m*/
 *         the matching to bound the cost for
 * @param currentMatchings
 *         all matchings
 * @param parameters
 *         the cost model parameters
 * @return the bounded ordering violation cost
 */
private Bounds boundOrderingCost(CMMatching<T> matching, CMMatchings<T> currentMatchings,
        CMParameters<T> parameters) {
    float lower, upper;
    List<T> mosibs = otherSiblings(matching.m, currentMatchings, parameters);
    List<T> nosibs = otherSiblings(matching.n, currentMatchings, parameters);
    Stream<T> siblings = concat(mosibs.stream(), nosibs.stream());

    boolean orderingPossible = siblings.allMatch(
            sib -> containing(sib, currentMatchings, parameters).stream().anyMatch(match -> match.isNoMatch()
                    || !violatesOrdering(match, matching, currentMatchings, parameters)));

    if (!orderingPossible) {
        lower = parameters.wo.weigh(matching);
        upper = lower;
    } else {
        lower = 0;

        siblings = concat(mosibs.stream(), nosibs.stream());

        boolean violationPossible = siblings.anyMatch(sib -> containing(sib, currentMatchings, parameters)
                .stream().anyMatch(match -> !match.isNoMatch()
                        && violatesOrdering(match, matching, currentMatchings, parameters)));

        upper = violationPossible ? parameters.wo.weigh(matching) : 0;
    }

    return new Bounds(lower, upper);
}

---

From source file:org.fenixedu.academic.ui.struts.action.administrativeOffice.lists.StudentListByDegreeDA.java

private static List<RegistrationWithStateForExecutionYearBean> filterResults(
        SearchStudentsByDegreeParametersBean searchBean, final Set<Registration> registrations,
        final ExecutionYear executionYear) {
    final List<RegistrationWithStateForExecutionYearBean> result = new ArrayList<RegistrationWithStateForExecutionYearBean>();
    for (final Registration registration : registrations) {
        if (searchBean.hasAnyRegistrationProtocol()
                && !searchBean.getRegistrationProtocols().contains(registration.getRegistrationProtocol())) {
            continue;
        }/*from   w w w.ja v a 2s. c  o  m*/

        if (searchBean.hasAnyStudentStatuteType() && !hasStudentStatuteType(searchBean, registration)) {
            continue;
        }

        final RegistrationState lastRegistrationState = registration.getLastRegistrationState(executionYear);
        if (lastRegistrationState == null) {
            continue;
        }
        if (searchBean.hasAnyRegistrationStateTypes()
                && !searchBean.getRegistrationStateTypes().contains(lastRegistrationState.getStateType())) {
            continue;
        }

        if ((searchBean.isIngressedInChosenYear()) && (registration.getIngressionYear() != executionYear)) {
            continue;
        }

        if (searchBean.isConcludedInChosenYear()) {
            Stream<ProgramConclusion> conclusions = ProgramConclusion.conclusionsFor(registration)
                    .filter(ProgramConclusion::isTerminal);

            if (conclusions.allMatch(programConclusion -> {
                RegistrationConclusionBean conclusionBean = new RegistrationConclusionBean(registration,
                        programConclusion);
                return conclusionBean.getCurriculumGroup() == null || !conclusionBean.isConcluded()
                        || conclusionBean.getConclusionYear() != executionYear;
            })) {
                continue;
            }
        }

        if (searchBean.getActiveEnrolments() && !registration.hasAnyEnrolmentsIn(executionYear)) {
            continue;
        }

        if (searchBean.getStandaloneEnrolments() && !registration.hasAnyStandaloneEnrolmentsIn(executionYear)) {
            continue;
        }

        if ((searchBean.getRegime() != null)
                && (registration.getRegimeType(executionYear) != searchBean.getRegime())) {
            continue;
        }

        if ((searchBean.getNationality() != null)
                && (registration.getPerson().getCountry() != searchBean.getNationality())) {
            continue;
        }

        if ((searchBean.getIngressionType() != null)
                && (registration.getIngressionType() != searchBean.getIngressionType())) {
            continue;
        }

        result.add(new RegistrationWithStateForExecutionYearBean(registration,
                lastRegistrationState.getStateType(), executionYear));
    }
    return result;
}

---