public static <F, T> CloseableIterator<T> transform( Iterator<F> iterator, Function<? super F, ? extends T> function) { Iterator<T> transformedNotCloseable = Iterators.transform(iterator, function); Closeable closeable = (Closeable) (iterator instanceof CloseableIterator ? iterator : null); return new CloseableIteratorAdapter<T>(transformedNotCloseable, closeable); }
@Override public boolean hasNext() { boolean hasNext = wrapped.hasNext(); if (!hasNext) { // auto close close(); } return hasNext; }
@Override public <T extends CatalogInfo> CloseableIterator<T> list( Class<T> of, Filter filter, Integer offset, Integer count, SortBy sortBy) { Filter securityFilter = securityFilter(of, filter); CloseableIterator<T> filtered; filtered = delegate.list(of, securityFilter, offset, count, sortBy); // create secured decorators on-demand. Assume this method is used only for listing, not // for accessing a single resource by name/id, thus use hide policy for mixed mode final Function<T, T> securityWrapper = securityWrapper(of, MixedModeBehavior.HIDE); final CloseableIterator<T> filteredWrapped; filteredWrapped = CloseableIteratorAdapter.transform(filtered, securityWrapper); // wrap the iterator in a notNull filter to ensure any filtered // layers (result is null) don't get passed on from the securityWrapper // Function. When the AccessLevel is HIDDEN and a layer gets filtered // out via a CatalogFilter - for example, this can happen with a // LocalWorkspaceCatalogFilter and a virtual service request return CloseableIteratorAdapter.filter( filteredWrapped, com.google.common.base.Predicates.<T>notNull()); }
public static <T> CloseableIterator<T> filter(final Iterator<T> iterator, final Filter filter) { Predicate<T> predicate = filterAdapter(filter); return filter(iterator, predicate); }
@Override public <T extends CatalogInfo> CloseableIterator<T> list( Class<T> of, Filter filter, Integer offset, Integer count, SortBy sortBy) { Filter securityFilter = securityFilter(of, filter); CloseableIterator<T> filtered; filtered = delegate.list(of, securityFilter, offset, count, sortBy); // create secured decorators on-demand final Function<T, T> securityWrapper = securityWrapper(of); final CloseableIterator<T> filteredWrapped; filteredWrapped = CloseableIteratorAdapter.transform(filtered, securityWrapper); return filteredWrapped; }
static <T> CloseableIterator<T> makeCIterator(List<T> source, Filter f) { return CloseableIteratorAdapter.filter(source.iterator(), f); } }
/** * Returns a decorating iterator over the one returned by the delegate that wraps every object * it returns, if possible. * * @see #wrap(Object, Class) * @see org.geoserver.catalog.Catalog#list(java.lang.Class, org.geoserver.catalog.Predicate, * java.lang.Integer, java.lang.Integer, org.geoserver.catalog.OrderBy) */ @Override public <T extends CatalogInfo> CloseableIterator<T> list( final Class<T> of, final Filter filter, final Integer offset, final Integer count, final SortBy sortBy) { CloseableIterator<T> iterator = delegate.list(of, filter, offset, count, sortBy); if (iterator.hasNext() && useNameDequalifyingProxy()) { return CloseableIteratorAdapter.transform( iterator, obj -> obj == null ? null : NameDequalifyingProxy.create(obj, of)); } return iterator; }
static <T> CloseableIterator<T> makeCIterator(List<T> source, Filter f) { return CloseableIteratorAdapter.filter(source.iterator(), f); }
public static <T> CloseableIterator<T> filter( final Iterator<T> iterator, final Predicate<T> predicate) { UnmodifiableIterator<T> filteredNotCloseable = Iterators.filter(iterator, predicate); Closeable closeable = iterator instanceof Closeable ? (Closeable) iterator : null; return new CloseableIteratorAdapter<T>(filteredNotCloseable, closeable); }
@Override protected void finalize() { if (whatToClose != null) { try { close(); } finally { LOGGER.warning( "There is code not closing CloseableIterator!!! Auto closing at finalize()."); } } }
public <T extends CatalogInfo> CloseableIterator<T> list( Class<T> of, Filter filter, Integer offset, Integer count, SortBy... sortBy) { Filter securityFilter = securityFilter(of, filter); CloseableIterator<T> filtered; // HACK here, go straigth to the facade of the delegate to get a method supporting sortby[] filtered = delegate.getFacade().list(of, securityFilter, offset, count, sortBy); // create secured decorators on-demand. Assume this method is used only for listing, not // for accessing a single resource by name/id, thus use hide policy for mixed mode final Function<T, T> securityWrapper = securityWrapper(of, MixedModeBehavior.HIDE); final CloseableIterator<T> filteredWrapped; filteredWrapped = CloseableIteratorAdapter.transform(filtered, securityWrapper); // wrap the iterator in a notNull filter to ensure any filtered // layers (result is null) don't get passed on from the securityWrapper // Function. When the AccessLevel is HIDDEN and a layer gets filtered // out via a CatalogFilter - for example, this can happen with a // LocalWorkspaceCatalogFilter and a virtual service request return CloseableIteratorAdapter.filter( filteredWrapped, com.google.common.base.Predicates.<T>notNull()); }
catalog.list(PublishedInfo.class, filter, (int) first, (int) count, sortOrder); return CloseableIteratorAdapter.transform( pi, new Function<PublishedInfo, PreviewLayer>() {
@Override public CloseableIterator<FeatureTypeInfo> answer() throws Throwable { Filter filter = filterCapture.getValue(); return CloseableIteratorAdapter.filter(source.iterator(), filter); } });
public static <T> CloseableIterator<T> empty() { Iterator<T> empty = Collections.emptyIterator(); return new CloseableIteratorAdapter<T>(empty); }
@Override public Iterator<StyleInfo> iterator(final long first, final long count) { Iterator<StyleInfo> iterator = filteredItems((int) first, (int) count); if (iterator instanceof CloseableIterator) { // don't know how to force wicket to close the iterator, lets return // a copy. Shouldn't be much overhead as we're paging try { return Lists.newArrayList(iterator).iterator(); } finally { CloseableIteratorAdapter.close(iterator); } } else { return iterator; } }
public static <T> CloseableIterator<T> limit(final Iterator<T> iterator, int maxElements) { Iterator<T> limitedNotCloseable = Iterators.limit(iterator, maxElements); Closeable closeable = iterator instanceof Closeable ? (Closeable) iterator : null; return new CloseableIteratorAdapter<T>(limitedNotCloseable, closeable); }
@Override public Iterator<StoreInfo> iterator(final long first, final long count) { Iterator<StoreInfo> iterator = filteredItems(first, count); if (iterator instanceof CloseableIterator) { // don't know how to force wicket to close the iterator, lets return // a copy. Shouldn't be much overhead as we're paging try { return Lists.newArrayList(iterator).iterator(); } finally { CloseableIteratorAdapter.close(iterator); } } else { return iterator; } }
/** * Helper method that consumes a catalog objects iterator keeping only the ones visible in the * current context. * * @param objects iterator over catalog objects * @param filter filter that checks if an element should be visible * @return an iterator over the catalog objects visible in the current context */ private <T extends CatalogInfo> CloseableIterator<T> filterIsolated( CloseableIterator<T> objects, Function<T, T> filter) { List<T> iterable = new ArrayList<>(); // consume the iterator while (objects.hasNext()) { T object = objects.next(); if (filter.apply(object) != null) { // this catalog object is visible in the current context iterable.add(object); } } // create an iterator for the visible catalog objects return new CloseableIteratorAdapter<>(iterable.iterator()); }
@Override public Iterator<PreviewLayer> iterator(final long first, final long count) { Iterator<PreviewLayer> iterator = filteredItems(first, count); if (iterator instanceof CloseableIterator) { // don't know how to force wicket to close the iterator, lets return // a copy. Shouldn't be much overhead as we're paging try { return Lists.newArrayList(iterator).iterator(); } finally { CloseableIteratorAdapter.close(iterator); } } else { return iterator; } }
@Override public <T extends CatalogInfo> CloseableIterator<T> list( final Class<T> of, final Filter filter, @Nullable Integer offset, @Nullable Integer count, @Nullable SortBy... sortOrder) { if (sortOrder != null) { for (SortBy so : sortOrder) { if (sortOrder != null && !canSort(of, so.getPropertyName().getPropertyName())) { throw new IllegalArgumentException( "Can't sort objects of type " + of.getName() + " by " + so.getPropertyName()); } } } Iterable<T> iterable = iterable(of, filter, sortOrder); if (offset != null && offset.intValue() > 0) { iterable = Iterables.skip(iterable, offset.intValue()); } if (count != null && count.intValue() >= 0) { iterable = Iterables.limit(iterable, count.intValue()); } Iterator<T> iterator = iterable.iterator(); return new CloseableIteratorAdapter<T>(iterator); }