Example usage for com.google.common.collect Iterables isEmpty

Introduction

In this page you can find the example usage for com.google.common.collect Iterables isEmpty.

Prototype

public static boolean isEmpty(Iterable<?> iterable)

Source Link

Document

Determines if the given iterable contains no elements.

Usage

From source file:com.google.javascript.rhino.TypeDeclarationsIR.java

/**
 * Represents a parameterized, or generic, type.
 * Closure calls this a Type Application and accepts syntax like
 * {@code {Object.<string, number>}}
 *
 * <p>Example:/*from  www.  ja  v a 2s.  c  o m*/
 * <pre>
 * PARAMETERIZED_TYPE
 *   NAMED_TYPE
 *     NAME Object
 *   STRING_TYPE
 *   NUMBER_TYPE
 * </pre>
 * @param baseType
 * @param typeParameters
 */
public static TypeDeclarationNode parameterizedType(TypeDeclarationNode baseType,
        Iterable<TypeDeclarationNode> typeParameters) {
    if (Iterables.isEmpty(typeParameters)) {
        return baseType;
    }
    TypeDeclarationNode node = new TypeDeclarationNode(Token.PARAMETERIZED_TYPE, baseType);
    for (Node typeParameter : typeParameters) {
        node.addChildToBack(typeParameter);
    }
    return node;
}

From source file:org.eclipse.sirius.diagram.ui.tools.internal.actions.repair.AbstractDiagramElementState.java

/**
 * {@inheritDoc}/*from  ww w.ja v  a  2s  . c  o m*/
 */
@Override
public void storeElementState(EObject target, DiagramElementMapping mapping, D element) {
    customizableToCustomizedFeatures.clear();
    isVisible = element.isVisible();

    // handle isHidden
    DDiagramElementQuery dDiagramElementQuery = new DDiagramElementQuery(element);
    isHidden = dDiagramElementQuery.isHidden();
    isLabelHidden = dDiagramElementQuery.isLabelHidden();

    storeFold(element);

    // Will now cross reference to find the GMF nodes referencing this
    // element.
    final Iterator<Map.Entry<EObject, Collection<Setting>>> referencesIterator = crossReferencer.entrySet()
            .iterator();
    while (referencesIterator.hasNext()) {
        final Map.Entry<EObject, Collection<Setting>> reference = referencesIterator.next();
        if (reference.getKey().equals(element)) {
            final List<Setting> valueList = (List<Setting>) reference.getValue();
            for (int i = 0; i < valueList.size(); i++) {
                final EStructuralFeature.Setting nextNodeSetting = valueList.get(i);
                // Can only be Node or Edge. ClassCastExceptions here
                // indicates a change in DiagramCrossReferencer
                if (nextNodeSetting.getEObject() instanceof Node) {
                    nodes.add((Node) nextNodeSetting.getEObject());
                } else {
                    edges.add((Edge) nextNodeSetting.getEObject());
                }
            }
        }
    }

    final Style ownedStyle = element.getStyle();
    if (ownedStyle != null) {
        storeStyleCustomizations(ownedStyle);
    }

    Iterable<AbsoluteBoundsFilter> flags = Iterables.filter(element.getGraphicalFilters(),
            AbsoluteBoundsFilter.class);
    if (!Iterables.isEmpty(flags)) {
        Iterables.addAll(boundsFilters, flags);
    }

    // If DDiagramElement is bordered node and is collapsed, the stored size
    // should be the expanded one. The size will be collapsed by the refresh
    // after restore.
    Predicate<Object> predicate = new Predicate<Object>() {

        @Override
        public boolean apply(Object input) {
            if (input instanceof CollapseFilter) {
                if (((CollapseFilter) input).eIsSet(DiagramPackage.eINSTANCE.getCollapseFilter_Height())
                        && ((CollapseFilter) input)
                                .eIsSet(DiagramPackage.eINSTANCE.getCollapseFilter_Width())) {
                    return true;
                }
            }
            return false;
        }
    };

    // if the node is collapsed, we save its expanded bounds.
    Iterable<GraphicalFilter> elementCollapseFilters = Iterables.filter(element.getGraphicalFilters(),
            predicate);
    if (!Iterables.isEmpty(elementCollapseFilters)) {
        GraphicalFilter graphicalFilter = Iterables.get(elementCollapseFilters, 0);
        if (graphicalFilter instanceof CollapseFilter) {
            expandedDimension = new Dimension(((CollapseFilter) graphicalFilter).getWidth(),
                    ((CollapseFilter) graphicalFilter).getHeight());
        }

    }
}

From source file:com.github.nethad.clustermeister.provisioning.jppf.JPPFManagementByJobsClient.java

/**
 * @throws Exception when the job submission failed.
 *//*from w w w.  j av a 2s  .  c o  m*/
private void submitJob(JPPFJob job) throws Exception {
    List<JPPFTask> tasks = jPPFClient.submit(job);
    if (job.isBlocking()) {
        if (tasks != null && !tasks.isEmpty()) {
            Iterable<JPPFTask> failedTasks = Iterables.filter(tasks, new Predicate<JPPFTask>() {
                @Override
                public boolean apply(JPPFTask task) {
                    return task != null && task.getException() != null;
                }
            });
            if (!Iterables.isEmpty(failedTasks)) {
                logger.warn("{} tasks raised an exception.", Iterables.size(failedTasks));
                if (logger.isDebugEnabled()) {
                    for (JPPFTask failedTask : failedTasks) {
                        logger.debug("{} failed with: {}.", failedTask.getId(),
                                failedTask.getException().getMessage());
                    }
                }
            }
        } else {
            logger.warn("Task list for job {} is empty.", job.getName());
        }
        logger.info("Job {} completed.", job.getName());
    } else {
        logger.info("Job {} submitted.", job.getName());
    }
}

From source file:com.google.errorprone.BugCheckerRefactoringTestHelper.java

private JCCompilationUnit doCompile(final JavaFileObject input, Iterable<JavaFileObject> files, Context context)
        throws IOException {
    JavacTool tool = JavacTool.create();
    DiagnosticCollector<JavaFileObject> diagnosticsCollector = new DiagnosticCollector<>();
    context.put(ErrorProneOptions.class, ErrorProneOptions.empty());
    JavacTaskImpl task = (JavacTaskImpl) tool.getTask(CharStreams.nullWriter(), fileManager,
            diagnosticsCollector, options, /*classes=*/ null, files, context);
    Iterable<? extends CompilationUnitTree> trees = task.parse();
    task.analyze();//from w ww  . j  a v a  2s.  c o m
    JCCompilationUnit tree = Iterables
            .getOnlyElement(Iterables.filter(Iterables.filter(trees, JCCompilationUnit.class),
                    compilationUnit -> compilationUnit.getSourceFile() == input));
    Iterable<Diagnostic<? extends JavaFileObject>> errorDiagnostics = Iterables
            .filter(diagnosticsCollector.getDiagnostics(), d -> d.getKind() == Diagnostic.Kind.ERROR);
    if (!Iterables.isEmpty(errorDiagnostics)) {
        fail("compilation failed unexpectedly: " + errorDiagnostics);
    }
    return tree;
}

From source file:org.polarsys.reqcycle.ocl.utils.OCLUtilities.java

/**
 * Gets operations that could be used to match uml elements to a data type. These operations must have a specific name and signature (no parameter, return boolean).
 *///from  ww  w. j  a v  a2 s  .  c  o m
public static Iterable<DefOperationCS> getMatchingOperations(final IAttribute attribute,
        BaseResource resource) {
    Collection<DefOperationCS> operations = getOperations(resource);
    if (operations == null || Iterables.isEmpty(operations)) {
        return Collections.emptyList();
    }
    return Iterables.filter(operations, new Predicate<DefOperationCS>() {

        @Override
        public boolean apply(DefOperationCS arg0) {
            TypedRefCS operationReturnType = arg0.getOwnedType();
            if (!arg0.getParameters().isEmpty()) {
                return false;
            }
            if (operationReturnType instanceof PrimitiveTypeRefCS) {
                String returnType = ((PrimitiveTypeRefCS) operationReturnType).getName();
                String attributeTypeName = attribute.getType().getName();
                String lookupResult = mapToOCLPrimitives.get(attributeTypeName);
                if (lookupResult == null || !lookupResult.equals(returnType)) {
                    return false;
                }
            }
            return arg0.getName().equalsIgnoreCase(getOperationRequiredName(attribute));
        }
    });
}

From source file:com.google.devtools.build.lib.skyframe.SkyframeTargetPatternEvaluator.java

ResolvedTargets<Target> parseTargetPatternKeys(Iterable<SkyKey> patternSkyKeys, int numThreads,
        boolean keepGoing, EventHandler eventHandler, TargetPatternsResultBuilder finalTargetSetEvaluator)
        throws InterruptedException, TargetParsingException {
    EvaluationResult<TargetPatternValue> result = skyframeExecutor.targetPatterns(patternSkyKeys, numThreads,
            keepGoing, eventHandler);/*from  w w  w.  ja  v  a 2 s .  com*/

    String errorMessage = null;
    for (SkyKey key : patternSkyKeys) {
        TargetPatternValue resultValue = result.get(key);
        if (resultValue != null) {
            ResolvedTargets<Label> results = resultValue.getTargets();
            if (((TargetPatternValue.TargetPatternKey) key.argument()).isNegative()) {
                finalTargetSetEvaluator.addLabelsOfNegativePattern(results);
            } else {
                finalTargetSetEvaluator.addLabelsOfPositivePattern(results);
            }
        } else {
            TargetPatternValue.TargetPatternKey patternKey = (TargetPatternValue.TargetPatternKey) key
                    .argument();
            String rawPattern = patternKey.getPattern();
            ErrorInfo error = result.errorMap().get(key);
            if (error == null) {
                Preconditions.checkState(!keepGoing);
                continue;
            }
            if (error.getException() != null) {
                // This exception may not be a TargetParsingException because in a nokeep_going build, the
                // target pattern parser may swallow a NoSuchPackageException but the framework will
                // bubble it up anyway.
                Preconditions.checkArgument(
                        !keepGoing || error.getException() instanceof TargetParsingException, error);
                errorMessage = error.getException().getMessage();
            } else if (!Iterables.isEmpty(error.getCycleInfo())) {
                errorMessage = "cycles detected during target parsing";
                skyframeExecutor.getCyclesReporter().reportCycles(error.getCycleInfo(), key, eventHandler);
            } else {
                throw new IllegalStateException(error.toString());
            }
            if (keepGoing) {
                eventHandler.handle(Event.error("Skipping '" + rawPattern + "': " + errorMessage));
            }
            finalTargetSetEvaluator.setError();

            if (eventHandler instanceof ParseFailureListener) {
                ParseFailureListener parseListener = (ParseFailureListener) eventHandler;
                parseListener.parsingError(rawPattern, errorMessage);
            }
        }
    }

    if (result.hasError()) {
        Preconditions.checkState(errorMessage != null, "unexpected errors: %s", result.errorMap());
        finalTargetSetEvaluator.setError();
        if (!keepGoing) {
            throw new TargetParsingException(errorMessage);
        }
    }
    WalkableGraph walkableGraph = Preconditions.checkNotNull(result.getWalkableGraph(), result);
    return finalTargetSetEvaluator.build(walkableGraph);
}

From source file:org.eclipse.tracecompass.internal.ctf.core.event.metadata.IOStructGen.java

private void parseIncompleteRoot(CommonTree root) throws ParseException {
    if (!fHasBeenParsed) {
        throw new ParseException("You need to run generate first"); //$NON-NLS-1$
    }/*from   w w w  .  java  2  s  .com*/
    List<CommonTree> children = root.getChildren();
    List<CommonTree> events = new ArrayList<>();
    for (CommonTree child : children) {
        final int type = child.getType();
        switch (type) {
        case CTFParser.DECLARATION:
            parseRootDeclaration(child);
            break;
        case CTFParser.TRACE:
            throw new ParseException(
                    "Trace block defined here, please use generate and not generateFragment to parse this fragment"); //$NON-NLS-1$
        case CTFParser.STREAM:
            StreamParser.INSTANCE.parse(child, new StreamParser.Param(fTrace, fRoot));
            break;
        case CTFParser.EVENT:
            events.add(child);
            break;
        case CTFParser.CLOCK:
            CTFClock ctfClock = ClockParser.INSTANCE.parse(child, null);
            String nameValue = ctfClock.getName();
            fTrace.addClock(nameValue, ctfClock);
            break;
        case CTFParser.ENV:
            fTrace.setEnvironment(EnvironmentParser.INSTANCE.parse(child, null));
            break;
        default:
            throw childTypeError(child);
        }
    }
    parseEvents(events, !Iterables.isEmpty(fTrace.getStreams()));
}

From source file:edu.mit.streamjit.impl.compiler2.ActorArchetype.java

public void generateCode(String packageName, ModuleClassLoader loader, Iterable<WorkerActor> actors) {
    assert workMethods == null : "already generated code for " + this;
    //If we've removed all instances of this archetype, don't spin an empty class.
    if (Iterables.isEmpty(actors))
        return;/*from  ww w. j a va 2  s.c o  m*/

    Module module = workerKlass.getParent();
    TypeFactory types = module.types();
    //We need to resolve work before making the state holder class so we
    //pick up its uses.
    Method oldWork = workerKlass.getMethodByVirtual("work",
            types.getMethodType(types.getVoidType(), types.getRegularType(workerKlass)));
    oldWork.resolve();

    Klass stateHolderKlass = makeStateHolderKlass(packageName);
    Klass archetypeKlass = new Klass(packageName + "." + workerKlass.getName() + "Archetype",
            module.getKlass(Object.class), ImmutableList.<Klass>of(), module);
    archetypeKlass.modifiers().addAll(EnumSet.of(Modifier.PUBLIC, Modifier.FINAL));

    Map<Pair<Class<?>, Class<?>>, Method> methods = new HashMap<>();
    for (WorkerActor a : actors) {
        Class<?> inputType = a.inputType().getRawType(), outputType = a.outputType().getRawType();
        Pair<Class<?>, Class<?>> key = new Pair<Class<?>, Class<?>>(inputType, outputType);
        if (methods.containsKey(key))
            continue;

        //We modify rwork while remapping so we need a fresh clone.
        Method rwork = makeRwork(archetypeKlass, stateHolderKlass);
        for (BasicBlock b : rwork.basicBlocks())
            for (Instruction i : ImmutableList.copyOf(b.instructions()))
                if (i.operands().contains(rwork.arguments().get(0)) ||
                //TODO: also check for superclass fields
                        i.operands().anyMatch(Predicates.<Value>in(workerKlass.fields())))
                    remapEliminatingReceiver(i, inputType, outputType, stateHolderKlass);

        assert rwork.arguments().get(0).uses().isEmpty();
        Method work = new Method(makeWorkMethodName(inputType, outputType), rwork.getType().dropFirstArgument(),
                EnumSet.of(Modifier.PUBLIC, Modifier.STATIC), archetypeKlass);
        Map<Value, Value> vmap = new IdentityHashMap<>();
        vmap.put(rwork.arguments().get(0), null);
        for (int i = 1; i < rwork.arguments().size(); ++i)
            vmap.put(rwork.arguments().get(i), work.arguments().get(i - 1));
        Cloning.cloneMethod(rwork, work, vmap);
        cleanWorkMethod(work);
        methods.put(key, work);
        rwork.eraseFromParent();
    }

    ImmutableMap.Builder<Pair<Class<?>, Class<?>>, MethodHandle> workMethodsBuilder = ImmutableMap.builder();
    try {
        Class<?> stateHolderClass = loader.loadClass(stateHolderKlass.getName());
        this.constructStateHolder = findConstructor(stateHolderClass);
        Class<?> archetypeClass = loader.loadClass(archetypeKlass.getName());
        ImmutableListMultimap<String, java.lang.reflect.Method> methodsByName = Multimaps
                .index(Arrays.asList(archetypeClass.getMethods()), java.lang.reflect.Method::getName);
        for (Pair<Class<?>, Class<?>> p : methods.keySet()) {
            String name = makeWorkMethodName(p.first, p.second);
            workMethodsBuilder.put(p,
                    MethodHandles.publicLookup().unreflect(Iterables.getOnlyElement(methodsByName.get(name))));
        }
    } catch (ClassNotFoundException | IllegalAccessException ex) {
        throw new AssertionError(ex);
    }
    this.workMethods = workMethodsBuilder.build();
}

From source file:com.spectralogic.ds3cli.command.GetBulk.java

private Iterable<Contents> getObjects(final Ds3ClientHelpers helper) throws IOException, CommandException {
    final Iterable<Contents> contentMatches = getContentMatches();
    if (Iterables.isEmpty(contentMatches)) {
        throw new CommandException("No matching objects in bucket " + this.bucketName);
    }//from  www  . jav  a2s  .  co  m
    if (this.sync) {
        final Iterable<Contents> filteredContents = this.filterContents(contentMatches, this.outputPath);
        if (Iterables.isEmpty(filteredContents)) {
            throw new CommandException("Nothing to do; all files are up to date");
        }
        return filteredContents;
    }
    return contentMatches;
}

From source file:com.twitter.common.zookeeper.CandidateImpl.java

@Nullable
private String getLeader(Iterable<String> memberIds) {
    return Iterables.isEmpty(memberIds) ? null : judge.apply(memberIds);
}