Example usage for com.google.common.collect Iterators emptyIterator

List of usage examples for com.google.common.collect Iterators emptyIterator

Introduction

In this page you can find the example usage for com.google.common.collect Iterators emptyIterator.

Prototype

@Deprecated
public static <T> UnmodifiableIterator<T> emptyIterator() 

Source Link

Document

Returns the empty iterator.

Usage

From source file:gobblin.data.management.copy.hive.HiveDataset.java

/**
 * Finds all files read by the table and generates CopyableFiles.
 * For the specific semantics see {@link HiveCopyEntityHelper#getCopyEntities}.
 *///from  www .j a v  a2  s .  co m
@Override
public Iterator<FileSet<CopyEntity>> getFileSetIterator(FileSystem targetFs, CopyConfiguration configuration,
        Comparator<FileSet<CopyEntity>> prioritizer, PushDownRequestor<FileSet<CopyEntity>> requestor)
        throws IOException {
    if (!canCopyTable()) {
        return Iterators.emptyIterator();
    }
    try {
        List<FileSet<CopyEntity>> fileSetList = Lists
                .newArrayList(new HiveCopyEntityHelper(this, configuration, targetFs)
                        .getCopyEntities(configuration, prioritizer, requestor));
        Collections.sort(fileSetList, prioritizer);
        return fileSetList.iterator();
    } catch (IOException ioe) {
        log.error("Failed to copy table " + this.table, ioe);
        return Iterators.emptyIterator();
    }
}

From source file:eu.numberfour.n4js.ui.internal.EclipseBasedN4JSWorkspace.java

@Override
public Iterator<URI> getArchiveIterator(final URI archiveLocation, String archiveRelativeLocation) {
    ZipInputStream stream = null;
    try {/*from   w  ww  .  j  a  v  a 2 s  .  co  m*/
        stream = getArchiveStream(archiveLocation);
        Iterator<ZipEntry> entries = getArchiveIterator(stream, archiveRelativeLocation);
        return toArchiveURIs(archiveLocation, entries);
    } catch (CoreException | IOException e) {
        return Iterators.emptyIterator();
    } finally {
        if (stream != null) {
            try {
                stream.close();
            } catch (IOException e) {
                // ignore
            }
        }
    }
}

From source file:org.richfaces.ui.toggle.tabPanel.AbstractTab.java

/**
 * If the VisitContext is not the RenderExtendedVisitContext, return the usual FacetsAndChildren iterator.
 * Otherwise return only the Facet iterator when a child visit is not required.
 *
 * This is useful to not render the tab contents when an item is not visible, while still visiting the header facets.
 *
 * @param visitContext The VisitContext of the component tree visit.
 *//*from   w w w  .  j a v a2s  . co  m*/
public static Iterator<UIComponent> getVisitableChildren(UIComponent component, VisitContext visitContext) {
    Iterator<UIComponent> kids;
    if (RenderExtendedVisitContext.isRenderExtendedVisitContext(visitContext)
            && component instanceof VisitChildrenRejectable
            && !((VisitChildrenRejectable) component).shouldVisitChildren()) {
        if (component.getFacetCount() > 0) {
            kids = component.getFacets().values().iterator();
        } else {
            kids = Iterators.emptyIterator();
        }
    } else {
        kids = component.getFacetsAndChildren();
    }
    return kids;
}

From source file:org.apache.jackrabbit.oak.spi.security.authentication.external.impl.principal.ExternalGroupPrincipalProvider.java

@Nonnull
@Override/*www  .j a v a2 s .  co m*/
public Iterator<? extends Principal> findPrincipals(@Nullable String nameHint, int searchType) {
    if (PrincipalManager.SEARCH_TYPE_NOT_GROUP != searchType) {
        Result result = findPrincipals(Strings.nullToEmpty(nameHint), false);
        if (result != null) {
            return Iterators.filter(new GroupPrincipalIterator(nameHint, result), Predicates.notNull());
        }
    }

    return Iterators.emptyIterator();
}

From source file:eu.esdihumboldt.hale.ui.instancevalidation.report.InstanceValidationReportDetailsPage.java

/**
 * Returns a valid instance selection for the current selection of the tree
 * viewer. Returns <code>null</code> if there is none.
 * // w w w.j av a 2  s.  c om
 * @return a valid instance selection for the current selection of the tree
 *         viewer or <code>null</code>
 */
private InstanceSelection getValidSelection() {
    ISelection viewerSelection = treeViewer.getSelection();
    if (!(viewerSelection instanceof ITreeSelection) || viewerSelection.isEmpty())
        return null;

    ITreeSelection treeSelection = (ITreeSelection) treeViewer.getSelection();
    TreePath firstPath = treeSelection.getPaths()[0]; // XXX use all paths
    // instead of first
    // only?

    InstanceValidationMessage firstMessage;
    Iterator<InstanceValidationMessage> restIter;

    if (firstPath.getLastSegment() instanceof InstanceValidationMessage) {
        firstMessage = (InstanceValidationMessage) firstPath.getLastSegment();
        restIter = Iterators.emptyIterator();
    } else {
        Collection<InstanceValidationMessage> messages = contentProvider
                .getMessages(treeSelection.getPaths()[0]);
        if (messages.isEmpty())
            return null; // shouldn't happen, but doesn't really matter
        restIter = messages.iterator();
        firstMessage = restIter.next();
    }

    InstanceService is = (InstanceService) PlatformUI.getWorkbench().getService(InstanceService.class);
    // check first message for valid instance reference
    if (firstMessage.getInstanceReference() == null
            || is.getInstance(firstMessage.getInstanceReference()) == null)
        return null;

    Set<InstanceReference> references = new HashSet<InstanceReference>();
    references.add(firstMessage.getInstanceReference());
    while (restIter.hasNext())
        references.add(restIter.next().getInstanceReference());

    return new DefaultInstanceSelection(references.toArray());
}

From source file:alluxio.master.meta.DefaultMetaMaster.java

@Override
public Iterator<JournalEntry> getJournalEntryIterator() {
    return Iterators.emptyIterator();
}

From source file:org.apache.jackrabbit.oak.security.user.UserPrincipalProvider.java

@Nonnull
@Override/*from  ww  w .j av  a2  s  . com*/
public Iterator<? extends Principal> findPrincipals(final String nameHint, final int searchType) {
    try {
        AuthorizableType type = AuthorizableType.getType(searchType);
        StringBuilder statement = new StringBuilder()
                .append(QueryUtil.getSearchRoot(type, config.getParameters())).append("//element(*,")
                .append(QueryUtil.getNodeTypeName(type)).append(')').append("[jcr:like(@rep:principalName,'")
                .append(buildSearchPattern(nameHint)).append("')]");

        Result result = root.getQueryEngine().executeQuery(statement.toString(), javax.jcr.query.Query.XPATH,
                NO_BINDINGS, namePathMapper.getSessionLocalMappings());

        Iterator<Principal> principals = Iterators.filter(
                Iterators.transform(result.getRows().iterator(), new ResultRowToPrincipal()),
                Predicates.notNull());

        if (matchesEveryone(nameHint, searchType)) {
            principals = Iterators.concat(principals,
                    Iterators.singletonIterator(EveryonePrincipal.getInstance()));
            return Iterators.filter(principals, new EveryonePredicate());
        } else {
            return principals;
        }
    } catch (ParseException e) {
        log.debug(e.getMessage());
        return Iterators.emptyIterator();
    }
}

From source file:org.geogit.osm.internal.history.HistoryDownloader.java

private Iterator<Change> parseChanges(Supplier<Optional<File>> file) {

    ChangesetContentsScanner scanner = new ChangesetContentsScanner();

    final Optional<File> changesFile;
    try {//from ww  w  .ja  va  2 s. com
        changesFile = file.get();
    } catch (RuntimeException e) {
        Throwable cause = e.getCause();
        if (cause instanceof FileNotFoundException) {
            return Iterators.emptyIterator();
        }
        throw Throwables.propagate(e);
    }
    if (!changesFile.isPresent()) {
        return Iterators.emptyIterator();
    }
    final File actualFile = changesFile.get();
    final InputStream stream = openStream(actualFile);
    final Iterator<Change> changes;
    try {
        changes = scanner.parse(stream);
    } catch (XMLStreamException e) {
        throw Throwables.propagate(e);
    }

    return new AbstractIterator<Change>() {
        @Override
        protected Change computeNext() {
            if (!changes.hasNext()) {
                Closeables.closeQuietly(stream);
                if (!preserveFiles) {
                    actualFile.delete();
                    actualFile.getParentFile().delete();
                }
                return super.endOfData();
            }
            return changes.next();
        }
    };
}

From source file:com.android.tools.lint.detector.api.JavaContext.java

@NonNull
public static Iterator<Expression> getParameters(@NonNull Node call) {
    if (call instanceof MethodInvocation) {
        return ((MethodInvocation) call).astArguments().iterator();
    } else if (call instanceof ConstructorInvocation) {
        return ((ConstructorInvocation) call).astArguments().iterator();
    } else if (call instanceof EnumConstant) {
        return ((EnumConstant) call).astArguments().iterator();
    } else {/*from w  ww .j a v a  2s . c o  m*/
        return Iterators.emptyIterator();
    }
}

From source file:eu.numberfour.n4js.resource.N4JSUnloader.java

/**
 * Traverse the contents of the object that is contained in the {@link ObjectToFragment}. The string builder is used
 * as an accumulating parameter. That is, during the traversal it will be used and trimmed again. This allows to
 * reuse the underlying char array which is already copied when the fragment is turned into a string.
 *
 * The fragments use the very same notation as described in
 * {@link InternalEObject#eURIFragmentSegment(EStructuralFeature, EObject)}.
 *
 * The implementation from {@link ResourceImpl} uses a {@link SegmentSequence} rather than a {@link StringBuilder}.
 * Since we have to concatenate the string in the end anyway.
 *///from w ww.  j  ava 2 s.c  om
private static Iterator<ObjectToFragment> getAllProperContents(ObjectToFragment eObject,
        final StringBuilder result) {
    // we inherit from the AbstractTreeIterator which will help us getting a proper pre-order traversal
    return new AbstractTreeIterator<ObjectToFragment>(eObject, false /* don't resolve containment proxies */) {

        @Override
        public Iterator<ObjectToFragment> getChildren(Object parent) {
            final EObject current = ((ObjectToFragment) parent).object;
            final EStructuralFeature[] containments = containmentFeatures(current);
            if (containments == null || containments.length == 0) {
                // no containment features found, exit
                return Iterators.emptyIterator();
            }
            // we have at least one containment feature - append the fragment delimiter '/'
            result.append('/');
            // and concatenate all the iterators for the children
            return Iterators.concat(getFeatureIterators(current, containments));
        }

        /**
         * Returns an iterator of iterators. Each nested iterator covers a single containment feature. If the
         * feature is multi valued, the nested iterator has as many values as are set on the feature.
         */
        private Iterator<Iterator<ObjectToFragment>> getFeatureIterators(EObject current,
                EStructuralFeature[] containments) {
            return new AbstractIterator<Iterator<ObjectToFragment>>() {
                /**
                 * The length of the string builder before something was added by this traversing iterator.
                 */
                private final int prevLength = result.length();

                private int featureIdx = 0;

                @Override
                protected Iterator<ObjectToFragment> computeNext() {
                    while (featureIdx < containments.length) {
                        EStructuralFeature containment = containments[featureIdx];
                        featureIdx++;
                        // only consider features that have values
                        if (current.eIsSet(containment)) {
                            // reset the string builder
                            result.setLength(prevLength);
                            // append the @ sign and the feature name
                            // '@<feature-name>'
                            result.append('@').append(containment.getName());
                            // compute the contained values
                            return newValueIterator(containment);
                        }
                    }
                    return endOfData();
                }

                /**
                 * Returns an iterator for the values that are assigned to the given containment feature.
                 */
                private Iterator<ObjectToFragment> newValueIterator(EStructuralFeature feature) {
                    if (feature.isMany()) {
                        // add the dot as the delimiter between feature name and index in the list
                        result.append('.');
                        // compute the value indexes
                        return newManyValueIterator((List<?>) current.eGet(feature));
                    } else {
                        // no dot is added for single valued features
                        return newSingleValueIterator((EObject) current.eGet(feature));
                    }
                }

                /**
                 * Finalize the fragment for the given instance and return a singleton iterator for it.
                 */
                private Iterator<ObjectToFragment> newSingleValueIterator(EObject value) {
                    ObjectToFragment objectToFragment = new ObjectToFragment(value, result.toString());
                    return Iterators.singletonIterator(objectToFragment);
                }

                /**
                 * Traverse the list of values and return the feature indexes along with the values.
                 */
                private AbstractIterator<ObjectToFragment> newManyValueIterator(final List<?> values) {
                    return new AbstractIterator<ObjectToFragment>() {

                        /**
                         * The length of the string builder before something was added by this traversing iterator.
                         */
                        private final int prevLengthBeforeIdx = result.length();

                        /**
                         * The index in the value list.
                         */
                        private int valueIdx = 0;

                        @Override
                        protected ObjectToFragment computeNext() {
                            if (valueIdx < values.size()) {
                                EObject value = (EObject) values.get(valueIdx);
                                result.setLength(prevLengthBeforeIdx);
                                result.append(valueIdx);
                                valueIdx++;
                                return new ObjectToFragment(value, result.toString());
                            }
                            return endOfData();
                        }
                    };
                }
            };
        }

        private EStructuralFeature[] containmentFeatures(final EObject current) {
            return ((EClassImpl.FeatureSubsetSupplier) current.eClass().getEAllStructuralFeatures())
                    .containments();
        }
    };
}