Example usage for com.google.common.collect FluentIterable allMatch

Introduction

In this page you can find the example usage for com.google.common.collect FluentIterable allMatch.

Prototype

@CheckReturnValue
public final boolean allMatch(Predicate<? super E> predicate) 

Source Link

Document

Returns true if every element in this fluent iterable satisfies the predicate.

Usage

From source file:org.sosy_lab.cpachecker.core.algorithm.bmc.CandidateInvariantConjunction.java

private static boolean areMatchingLocationInvariants(Iterable<? extends CandidateInvariant> pElements) {
    FluentIterable<? extends CandidateInvariant> elements = FluentIterable.from(pElements);
    if (elements.isEmpty()) {
        return false;
    }//from w w  w  .ja v a  2  s .co m
    return elements.allMatch(lfi -> lfi instanceof LocationFormulaInvariant);
}

---

From source file:com.google.errorprone.bugpatterns.PrivateConstructorForUtilityClass.java

@Override
public Description matchClass(ClassTree classTree, VisitorState state) {
    if (!classTree.getKind().equals(CLASS)) {
        return NO_MATCH;
    }// w w w .  j  a v a 2s  .co m

    FluentIterable<? extends Tree> nonSyntheticMembers = FluentIterable.from(classTree.getMembers())
            .filter(Predicates.not(new Predicate<Tree>() {
                @Override
                public boolean apply(Tree tree) {
                    return tree.getKind().equals(METHOD) && isGeneratedConstructor((MethodTree) tree);
                }
            }));
    if (nonSyntheticMembers.isEmpty()) {
        return NO_MATCH;
    }
    boolean isUtilityClass = nonSyntheticMembers.allMatch(new Predicate<Tree>() {
        @Override
        public boolean apply(Tree tree) {
            switch (tree.getKind()) {
            case CLASS:
                return ((ClassTree) tree).getModifiers().getFlags().contains(STATIC);
            case METHOD:
                return ((MethodTree) tree).getModifiers().getFlags().contains(STATIC);
            case VARIABLE:
                return ((VariableTree) tree).getModifiers().getFlags().contains(STATIC);
            case BLOCK:
                return ((BlockTree) tree).isStatic();
            case ENUM:
            case ANNOTATION_TYPE:
            case INTERFACE:
                return true;
            default:
                throw new AssertionError("unknown member type:" + tree.getKind());
            }
        }
    });
    if (!isUtilityClass) {
        return NO_MATCH;
    }
    return describeMatch(classTree,
            addMembers(classTree, state, "private " + classTree.getSimpleName() + "() {}"));
}

---

From source file:com.google.errorprone.bugpatterns.inject.dagger.PrivateConstructorForNoninstantiableModule.java

@Override
public Description matchClass(ClassTree classTree, VisitorState state) {
    if (!DaggerAnnotations.isAnyModule().matches(classTree, state)) {
        return NO_MATCH;
    }// w w  w .j  a v  a  2 s. c  o m

    // if a module is declared as an interface, skip it
    if (!classTree.getKind().equals(CLASS)) {
        return NO_MATCH;
    }

    FluentIterable<? extends Tree> nonSyntheticMembers = FluentIterable.from(classTree.getMembers())
            .filter(Predicates.not(new Predicate<Tree>() {
                @Override
                public boolean apply(Tree tree) {
                    return tree.getKind().equals(METHOD) && isGeneratedConstructor((MethodTree) tree);
                }
            }));

    // ignore empty modules
    if (nonSyntheticMembers.isEmpty()) {
        return NO_MATCH;
    }

    if (nonSyntheticMembers.anyMatch(IS_CONSTRUCTOR)) {
        return NO_MATCH;
    }

    boolean hasBindingDeclarationMethods = nonSyntheticMembers
            .anyMatch(matcherAsPredicate(isBindingDeclarationMethod(), state));

    if (hasBindingDeclarationMethods) {
        return describeMatch(classTree, addPrivateConstructor(classTree, state));
    }

    boolean allStaticMembers = nonSyntheticMembers.allMatch(matcherAsPredicate(isStatic(), state));

    if (allStaticMembers) {
        return describeMatch(classTree, addPrivateConstructor(classTree, state));
    }

    return NO_MATCH;
}

---

From source file:org.sosy_lab.cpachecker.util.predicates.pathformula.PathFormulaManagerImpl.java

/**
 * Build a formula containing a predicate for all branching situations in the
 * ARG. If a satisfying assignment is created for this formula, it can be used
 * to find out which paths in the ARG are feasible.
 *
 * This method may be called with an empty set, in which case it does nothing
 * and returns the formula "true"./*from   w ww.j av a  2 s  .com*/
 *
 * @param elementsOnPath The ARG states that should be considered.
 * @return A formula containing a predicate for each branching.
 */
@Override
public BooleanFormula buildBranchingFormula(Iterable<ARGState> elementsOnPath)
        throws CPATransferException, InterruptedException {
    // build the branching formula that will help us find the real error path
    BooleanFormula branchingFormula = bfmgr.makeBoolean(true);
    for (final ARGState pathElement : elementsOnPath) {

        if (pathElement.getChildren().size() > 1) {
            if (pathElement.getChildren().size() > 2) {
                // can't create branching formula
                if (from(pathElement.getChildren()).anyMatch(AbstractStates.IS_TARGET_STATE)) {
                    // We expect this situation of one of the children is a target state created by PredicateCPA.
                    continue;
                } else {
                    logger.log(Level.WARNING, "ARG branching with more than two outgoing edges at ARG node "
                            + pathElement.getStateId() + ".");
                    return bfmgr.makeBoolean(true);
                }
            }

            FluentIterable<CFAEdge> outgoingEdges = from(pathElement.getChildren())
                    .transform(new Function<ARGState, CFAEdge>() {
                        @Override
                        public CFAEdge apply(ARGState child) {
                            return pathElement.getEdgeToChild(child);
                        }
                    });
            if (!outgoingEdges.allMatch(Predicates.instanceOf(AssumeEdge.class))) {
                if (from(pathElement.getChildren()).anyMatch(AbstractStates.IS_TARGET_STATE)) {
                    // We expect this situation of one of the children is a target state created by PredicateCPA.
                    continue;
                } else {
                    logger.log(Level.WARNING,
                            "ARG branching without AssumeEdge at ARG node " + pathElement.getStateId() + ".");
                    return bfmgr.makeBoolean(true);
                }
            }

            AssumeEdge edge = null;
            for (CFAEdge currentEdge : outgoingEdges) {
                if (((AssumeEdge) currentEdge).getTruthAssumption()) {
                    edge = (AssumeEdge) currentEdge;
                    break;
                }
            }
            assert edge != null;
            BooleanFormula pred = bfmgr.makeVariable(BRANCHING_PREDICATE_NAME + pathElement.getStateId(), 0);

            // create formula by edge, be sure to use the correct SSA indices!
            // TODO the class PathFormulaManagerImpl should not depend on PredicateAbstractState,
            // it is used without PredicateCPA as well.
            PathFormula pf;
            PredicateAbstractState pe = AbstractStates.extractStateByType(pathElement,
                    PredicateAbstractState.class);
            if (pe == null) {
                logger.log(Level.WARNING, "Cannot find precise error path information without PredicateCPA");
                return bfmgr.makeBoolean(true);
            } else {
                pf = pe.getPathFormula();
            }
            pf = this.makeEmptyPathFormula(pf); // reset everything except SSAMap
            pf = this.makeAnd(pf, edge); // conjunct with edge

            BooleanFormula equiv = bfmgr.equivalence(pred, pf.getFormula());
            branchingFormula = bfmgr.and(branchingFormula, equiv);
        }
    }
    return branchingFormula;
}

---