@Override public <T extends CatalogInfo> T get(Class<T> type, Filter filter) throws IllegalArgumentException { final Integer limit = Integer.valueOf(2); CloseableIterator<T> it = list(type, filter, null, limit, null); T result = null; try { if (it.hasNext()) { result = it.next(); if (it.hasNext()) { throw new IllegalArgumentException( "Specified query predicate resulted in more than one object"); } } } finally { it.close(); } return result; }
@Override public <T extends CatalogInfo> int count(Class<T> of, Filter filter) { CloseableIterator<T> found = facade.list(of, filter, null, null); try (CloseableIterator<T> filtered = filterIsolated(of, found)) { int count = 0; while (filtered.hasNext()) { count++; filtered.next(); } return count; } }
private List<LayerInfo> filterLayers(final Filter filter) { CloseableIterator<LayerInfo> iterator; iterator = list(LayerInfo.class, filter); try { return ImmutableList.copyOf(iterator); } finally { iterator.close(); } }
/** * 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; }
@Override public Object nextElement() { return it.next().getPrefix(); } };
/** * 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()); }
private <T> Set<T> asSet(CloseableIterator<T> list) { ImmutableSet<T> set; try { set = ImmutableSet.copyOf(list); } finally { list.close(); } return set; }
boolean layerConfigured(final WMTSStoreInfo store, final String nativeName) { final Filter filter = Predicates.and( Predicates.equal("store.name", store.getName()), Predicates.equal("nativeName", nativeName)); try (CloseableIterator<WMTSLayerInfo> it = catalog.list(WMTSLayerInfo.class, filter, 0, 1, null)) { return it.hasNext(); } }
private <T extends CatalogInfo> void testOrderBy( Class<T> clazz, Filter filter, Integer offset, Integer limit, SortBy sortOrder, List<T> expected) { CatalogPropertyAccessor pe = new CatalogPropertyAccessor(); List<Object> props = new ArrayList<Object>(); List<Object> actual = new ArrayList<Object>(); String sortProperty = sortOrder.getPropertyName().getPropertyName(); for (T info : expected) { Object pval = pe.getProperty(info, sortProperty); props.add(pval); } CloseableIterator<T> it = catalog.list(clazz, filter, offset, limit, sortOrder); try { while (it.hasNext()) { Object property = pe.getProperty(it.next(), sortProperty); actual.add(property); } } finally { it.close(); } assertEquals(props, actual); }
public void visit(LayerGroupInfo layerGroupToRemove) { Filter associatedTo = Predicates.equal("layers", layerGroupToRemove, MatchAction.ANY); try (CloseableIterator<LayerGroupInfo> it = catalog.list(LayerGroupInfo.class, associatedTo)) { while (it.hasNext()) { LayerGroupInfo group = it.next(); if (group.getLayers().contains(layerGroupToRemove)) { final List<PublishedInfo> layers = new ArrayList<>(group.getLayers()); layers.removeAll(objects.keySet()); if (layers.size() == 0) { visit(group); } else { add(group, ModificationType.GROUP_CHANGED); } } } } add(layerGroupToRemove, ModificationType.DELETE); } }
boolean layerConfigured(final WMSStoreInfo store, final String nativeName) { final Filter filter = Predicates.and( Predicates.equal("store.name", store.getName()), Predicates.equal("nativeName", nativeName)); try (CloseableIterator<WMSLayerInfo> it = catalog.list(WMSLayerInfo.class, filter, 0, 1, null)) { return it.hasNext(); } }
public void visit(LayerInfo layer) { // mark layer and resource as removed add(layer.getResource(), ModificationType.DELETE); add(layer, ModificationType.DELETE); // scan the layer groups and find those that do use the // current layer Filter groupContainsLayer = Predicates.equal("layers", layer, MatchAction.ANY); try (CloseableIterator<LayerGroupInfo> it = catalog.list(LayerGroupInfo.class, groupContainsLayer)) { while (it.hasNext()) { LayerGroupInfo group = it.next(); // mark the layer as one that will be removed Set<LayerInfo> layers = groups.get(group); if (layers == null) { layers = new HashSet<LayerInfo>(); groups.put(group, layers); } layers.add(layer); // a group can contain the same layer multiple times. We want to // make sure to mark the group as removed if all the layers inside of // it are going to be removed, just changed otherwise if (layers.size() == new HashSet<PublishedInfo>(group.getLayers()).size()) { visit(group); } else { add(group, ModificationType.GROUP_CHANGED); } } } }
@Override protected List<Tuple> load() { Catalog catalog = GeoServerApplication.get().getCatalog(); Filter filter = Predicates.acceptAll(); CloseableIterator<WorkspaceInfo> list = catalog.list(WorkspaceInfo.class, filter, null, 4000, null); List<Tuple> workspaces; try { workspaces = Lists.newArrayList( Iterators.transform( list, new Function<WorkspaceInfo, Tuple>() { @Override public Tuple apply(WorkspaceInfo input) { return new Tuple( input.getId(), input.getName()); } })); } finally { list.close(); } Collections.sort(workspaces); return workspaces; } };
@Override public boolean hasNext() { if (next != null) { return true; } boolean hasNext = featureTypes.hasNext(); if (!hasNext) { featureTypes.close(); return false; } else { try { FeatureTypeInfo featureType = featureTypes.next(); CollectionDocument collection = new CollectionDocument(geoServer, request, featureType); next = collection; return true; } catch (Exception e) { featureTypes.close(); throw new ServiceException( "Failed to iterate over the feature types in the catalog", e); } } }
while (it.hasNext()) { LayerInfo li = it.next(); if (style.equals(li.getDefaultStyle())) add(li, ModificationType.STYLE_RESET); else if (li.getStyles().contains(style)) try (CloseableIterator<LayerGroupInfo> it = catalog.list(LayerGroupInfo.class, groupAssociated)) { while (it.hasNext()) { LayerGroupInfo group = it.next(); if (style.equals(group.getRootLayerStyle())) { add(group, ModificationType.GROUP_CHANGED);