@Override public int compare(Object o1, Object o2) { Object v1 = OwsUtils.get(o1, sortOrder.getPropertyName().getPropertyName()); Object v2 = OwsUtils.get(o2, sortOrder.getPropertyName().getPropertyName()); if (v1 == null) { if (v2 == null) { return 0; } else { return -1; } } else if (v2 == null) { return 1; } Comparable c1 = (Comparable) v1; Comparable c2 = (Comparable) v2; return c1.compareTo(c2); } };
private SortOrder[] getSortOrders(LiteFeatureTypeStyle style) { SortBy[] sb = style.sortBy; SortOrder[] orders = new SortOrder[sb.length]; for (int i = 0; i < orders.length; i++) { orders[i] = sb[i].getSortOrder(); } return orders; }
final PropertyName propertyName = sortBy.getPropertyName(); final SortOrder sortOrder = sortBy.getSortOrder(); return new Comparator<SimpleFeature>() { @SuppressWarnings("unchecked")
SortBy sortBy = sortByList[i]; Ordering<Object> ordering = Ordering.from(comparator(sortBy)); if (SortOrder.DESCENDING.equals(sortBy.getSortOrder())) { ordering = ordering.reverse();
/** * Returns the sort order that matches the given string, or returns a new one if none match it. * * @param code The name of the code to fetch or to create. * @return A code matching the given name. */ public static SortOrder valueOf(String code) { return valueOf(SortOrder.class, code); } }
/** Returns the list of enumerations of the same kind than this enum. */ public SortOrder[] family() { return values(); }
public Object getProperty(Object object, QName name) throws Exception { SortBy sortBy = (SortBy) object; if (OGC.PropertyName.equals(name)) { return sortBy.getPropertyName(); } if ("SortOrder".equals(name.getLocalPart())) { return sortBy.getSortOrder(); } return null; } }
@Override public <T extends CatalogInfo> CloseableIterator<T> list( final Class<T> of, final Filter filter, Integer offset, Integer count, SortBy sortOrder) { CatalogFacade facade = getFacade(); if (sortOrder != null && !facade.canSort(of, sortOrder.getPropertyName().getPropertyName())) { // TODO: use GeoTools' merge-sort code to provide sorting anyways throw new UnsupportedOperationException( "Catalog backend can't sort on property " + sortOrder.getPropertyName() + " in-process sorting is pending implementation"); } return facade.list(of, filter, offset, count, sortOrder); }
/** Compares this object with the specified one for equality. */ @Override public boolean equals(final Object object) { if (object instanceof NullSortBy) { return order.equals(((NullSortBy) object).order); } return false; }
@SuppressWarnings("unchecked") protected int compare( SimpleFeature feature1, SimpleFeature feature2, SortBy order) { PropertyName name = order.getPropertyName(); Comparable value1 = (Comparable) name.evaluate(feature1); Comparable value2 = (Comparable) name.evaluate(feature2); if (value1 == value2) { return 0; } if (order.getSortOrder() == SortOrder.ASCENDING) { if (value1 == null) { return -1; } return value1.compareTo(value2); } else { if (value2 == null) { return -1; } return value2.compareTo(value1); } } });
@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); }
@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; SortByImpl other = (SortByImpl) obj; if (propertyName == null) { if (other.propertyName != null) return false; } else if (!propertyName.equals(other.propertyName)) return false; if (sortOrder == null) { if (other.sortOrder != null) return false; } else if (!sortOrder.equals(other.sortOrder)) return false; return true; }
@Override public boolean supportsSorting(final SortBy[] sortAttributes) { if (super.supportsSorting(sortAttributes)) return true; for (int i = 0; i < sortAttributes.length; i++) { SortBy sortBy = sortAttributes[i]; if (SortBy.NATURAL_ORDER == sortBy || SortBy.REVERSE_ORDER == sortBy) { // we do only if we have a non null primary key return !(source.getPrimaryKey() instanceof NullPrimaryKey); } else { PropertyName propertyName = sortBy.getPropertyName(); SortOrder sortOrder = sortBy.getSortOrder(); if (!supportsPropertySorting(propertyName, sortOrder)) { return false; } } } return true; }
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); }
protected SortBy[] unrollSortBy(SortBy[] sortArray) { if (sortArray == null) return null; ArrayList<SortBy> unrolledSorts = new ArrayList<>(); FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(GeoTools.getDefaultHints()); for (SortBy aSort : sortArray) { SortBy newSort = ff.sort( unrollIndex(aSort.getPropertyName(), mapping).getPropertyName(), aSort.getSortOrder()); unrolledSorts.add(newSort); } return unrolledSorts.toArray(new SortBy[] {}); }
/** * Returns all the properties used in the sortBy (excluding primary keys and the like, e.g., * natural sorting) * * @param sortBy * @return */ private Set<String> getSortPropertyNames(SortBy[] sortBy) { Set<String> result = new HashSet<>(); for (SortBy sort : sortBy) { PropertyName p = sort.getPropertyName(); if (p != null && p.getPropertyName() != null) { result.add(p.getPropertyName()); } } return result; }
/** * Extracts List of Sort attributes names from Query * * @param query * @return List of Sort attributes names */ public static List<String> getAttributesOnSort(Query query) { List<String> result = new ArrayList<>(); if (query.getSortBy() == null) return result; for (int i = 0; i < query.getSortBy().length; i++) { result.add(query.getSortBy()[i].getPropertyName().getPropertyName()); } return result; }
@Override public boolean supportsSorting(final SortBy[] sortAttributes) { final SimpleFeatureType featureType = typeInfo.getFeatureType(); for (SortBy sortBy : sortAttributes) { if (SortBy.NATURAL_ORDER == sortBy || SortBy.REVERSE_ORDER == sortBy) { // TODO: we should be able to support natural order return false; } else { String attName = sortBy.getPropertyName().getPropertyName(); AttributeDescriptor descriptor = featureType.getDescriptor(attName); if (descriptor == null) { return false; } if (descriptor instanceof GeometryDescriptor) { return false; } } } return true; } };
private void next() { if (iterator.hasNext()) { this.currentFeature = iterator.next(); // update the current key for (int i = 0; i < sortBy.length; i++) { SortBy sb = sortBy[i]; if (sb == SortBy.NATURAL_ORDER || sb == SortBy.REVERSE_ORDER) { currentKey.components[i] = currentFeature.getIdentifier().getID(); } else { Object value = sb.getPropertyName().evaluate(currentFeature); currentKey.components[i] = value; } } } else { // mark as complete but don't close, we might have // other fts to paint complete = true; } }