Refine search
private String sortByToString(LiteFeatureTypeStyle style, Class[] classes) { StringBuilder sb = new StringBuilder("Layer ").append(style.layer.getTitle()).append("["); SortBy[] sortBy = style.sortBy; for (int i = 0; i < sortBy.length; i++) { SortBy curr = sortBy[i]; if (curr == SortBy.NATURAL_ORDER) { sb.append("NaturalOrder"); } else if (curr == SortBy.REVERSE_ORDER) { sb.append("ReverseNaturalOrder"); } else { sb.append(curr.getPropertyName().getPropertyName()); sb.append("(").append(classes[i].getSimpleName()).append(")"); if (curr.getSortOrder() == SortOrder.DESCENDING) { sb.append(" D"); } } if (i < sortBy.length) { sb.append(", "); } } sb.append("]"); return sb.toString(); }
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; } }
@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 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); } };
AttributeType type = (AttributeType) sortBy[i].getPropertyName().evaluate( ft ); if ( type != null ) { sql.append( encoder.escapeName( type.getName() ) ); sql.append( encoder.escapeName( sortBy[i].getPropertyName().getPropertyName() ) ); if ( SortOrder.DESCENDING.equals( sortBy[i].getSortOrder() ) ) { sql.append( " DESC");
private void validateSort( FeatureSource<? extends FeatureType, ? extends Feature> source, SortBy[] sort, MapLayerInfo mapLayerInfo) { FeatureType ft = source.getSchema(); for (SortBy sortBy : sort) { if (sortBy.getPropertyName().evaluate(ft) == null) { throw new ServiceException( "Sort property '" + sortBy.getPropertyName().getPropertyName() + "' not available in " + mapLayerInfo.getName(), ServiceException.INVALID_PARAMETER_VALUE, "sortBy"); } } }
for (int i=0; i<q.getSortBy().length; i++) { SortBy sortby = q.getSortBy()[i]; Expression expr = (Expression) sortby.getPropertyName().accept(unmapper, null); throw new IOException("Sorting on " + sortby.getPropertyName() + " is not supported."); unmappedSortBy[i] = new SortByImpl((PropertyName) expr, sortby.getSortOrder());
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; } }
SortBy sortBy = sortByList[i]; Ordering<Object> ordering = Ordering.from(comparator(sortBy)); if (SortOrder.DESCENDING.equals(sortBy.getSortOrder())) { ordering = ordering.reverse();
LinkedHashSet<PropertyName> sortProperties = new LinkedHashSet<>(); for (SortBy sb : sortBy) { PropertyName pn = sb.getPropertyName(); if (pn != null) { sortProperties.add(pn);
@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); }
final PropertyName propertyName = sortBy.getPropertyName(); final SortOrder sortOrder = sortBy.getSortOrder(); return new Comparator<SimpleFeature>() { @SuppressWarnings("unchecked")
AttributeType type = (AttributeType) sortBy[i].getPropertyName().evaluate( ft ); if ( type != null ) { sql.append( encoder.escapeName( type.getName() ) ); sql.append( encoder.escapeName( sortBy[i].getPropertyName().getPropertyName() ) ); if ( SortOrder.DESCENDING.equals( sortBy[i].getSortOrder() ) ) { sql.append( " DESC");
void validateSortBy(List<SortBy> sortBys, FeatureTypeInfo meta, final GetFeatureRequest request) throws IOException { FeatureType featureType = meta.getFeatureType(); for (SortBy sortBy : sortBys) { PropertyName name = sortBy.getPropertyName(); if (name.evaluate(featureType) == null) { throw new WFSException( request, "Illegal property name: " + name.getPropertyName() + " for feature type " + meta.prefixedName(), "InvalidParameterValue"); } } }
protected int compare( Feature feature1, Feature feature2, SortBy order){ PropertyName name = order.getPropertyName(); Comparable value1 = (Comparable) name.evaluate( feature1 ); Comparable value2 = (Comparable) name.evaluate( feature2 ); if( order.getSortOrder() == SortOrder.ASCENDING ){ return value1.compareTo( value2 ); } else return value2.compareTo( value1 ); } });
for (int i = 0; i < q.getSortBy().length; i++) { SortBy sortby = q.getSortBy()[i]; Expression expr = (Expression) sortby.getPropertyName().accept(unmapper, null); "Sorting on " + sortby.getPropertyName() + " is not supported."); unmappedSortBy[i] = new SortByImpl((PropertyName) expr, sortby.getSortOrder());
private Class[] getSortByAttributeClasses(LiteFeatureTypeStyle style) { SortBy[] sb = style.sortBy; FeatureType schema = style.layer.getFeatureSource().getSchema(); Class[] classes = new Class[sb.length]; for (int i = 0; i < classes.length; i++) { PropertyName property = sb[i].getPropertyName(); if (property == null) { // natural sorts classes[i] = String.class; } else { PropertyDescriptor pd = property.evaluate(schema, null); if (pd == null) { throw new IllegalArgumentException( "Property " + property + " could not be found in feature type " + schema.getName() + " in layer " + style.layer.getTitle()); } classes[i] = pd.getType().getBinding(); } } return classes; }
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 PROPERTY = sortBy.getPropertyName(); return new Comparator<SimpleFeature>() { @SuppressWarnings("unchecked")
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[] {}); }