private void writeProperties(List<PropertyName> attributes, ObjectOutputStream oos) throws IOException { if (attributes == null) { oos.writeInt(-1); } else { oos.writeInt(attributes.size()); for (PropertyName property : attributes) { oos.writeObject(property.getPropertyName()); // TODO: write out the namespace support as well } } }
/** * Turns a list of {@link PropertyName} into a list of {@link String} * * @param names */ List<String> flattenNames(List<PropertyName> names) { if (names == null) { return null; } List<String> result = new ArrayList<String>(names.size()); for (PropertyName name : names) { result.add(name.getPropertyName()); } return result; }
/** * @param input the object to extract the (possibly nested,indexed, or collection) property from * @param propertyName the property to extract from {@code input} * @return the evaluated value of the given property, or {@code null} if a prior nested property * in the path is null; * @throws IllegalArgumentException if no such property exists for the given object */ public Object getProperty(final Object input, final String propertyName) throws IllegalArgumentException { if (input instanceof Info && Predicates.ANY_TEXT.getPropertyName().equals(propertyName)) { return getAnyText((Info) input); } String[] propertyNames = propertyName.split("\\."); return getProperty(input, propertyNames, 0); }
@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); } };
@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); }
SecuredSimpleFeatureCollection( FeatureCollection<SimpleFeatureType, SimpleFeature> delegate, WrapperPolicy policy) { super(delegate, policy); if (policy.getLimits() instanceof VectorAccessLimits) { List<PropertyName> properties = ((VectorAccessLimits) policy.getLimits()).getReadAttributes(); if (properties == null) { this.readSchema = getSchema(); } else { List<String> names = new ArrayList<String>(); for (PropertyName property : properties) { names.add(property.getPropertyName()); } String[] nameArray = (String[]) names.toArray(new String[names.size()]); try { this.readSchema = DataUtilities.createSubType(getSchema(), nameArray); } catch (SchemaException e) { // should just not happen throw new RuntimeException(e); } } } else { this.readSchema = getSchema(); } }
@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); }
public String getGeometryPropertyName() { if (geometry instanceof PropertyName) { PropertyName pg = (PropertyName) geometry; return pg.getPropertyName(); } return null; }
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); }
if (!securityProperties.contains(pn)) { throw new SecurityException( "Attribute " + pn.getPropertyName() + " is not available");
@Override public Object visit(PropertyName expression, Object extraData) { String name = expression.getPropertyName(); Expression ex = expressions.get(name); if (ex == null) { return super.visit(expression, extraData); } else { // inject the actual expression into the filter return ex; } } }
/** Internal parse method - made protected for unit testing */ protected String parseGeometryName(Node root) { Expression result = parseGeometry(root); if (result instanceof PropertyName) { return ((PropertyName) result).getPropertyName(); } return null; }
@Override public Object visit(PropertyName expression, Object extraData) { String prop = expression.getPropertyName(); if (extraData == Geometry.class) { return mapper.getGeometryPath(); } return mapper.getPropertyPath(prop); }
protected boolean isDefaultGeometry(PropertyName ae) { return reader.getFeatureType() .getGeometryDescriptor() .getLocalName() .equals(ae.getPropertyName()); }
@Override public Object visit(PropertyName expression, Object extraData) { final String propertyName = expression.getPropertyName(); if (propertyName != null && propertyName.equals(source)) { return getFactory(extraData).property(target); } else { return super.visit(expression, extraData); } }
public Object visit(PropertyName expression, Object extraData) { // NC - namespace support return getFactory(extraData) .property(expression.getPropertyName(), expression.getNamespaceContext()); }
public void testParse() throws Exception { FilterMockData.propertyName(document, document); PropertyName propertyName = (PropertyName) parse(); assertNotNull(propertyName); assertEquals("foo", propertyName.getPropertyName()); }
public void testRun() throws Exception { Object thing = parser.parse(getClass().getResourceAsStream("test1.xml")); assertNotNull(thing); assertTrue(thing instanceof PropertyIsEqualTo); PropertyIsEqualTo equal = (PropertyIsEqualTo) thing; assertTrue(equal.getExpression1() instanceof PropertyName); assertTrue(equal.getExpression2() instanceof Literal); PropertyName name = (PropertyName) equal.getExpression1(); assertEquals("testString", name.getPropertyName()); Literal literal = (Literal) equal.getExpression2(); assertEquals("2", literal.toString()); }
@Test public void testNullFilter() throws Exception { PropertyIsNull nullFilter = ff.isNull(ff.property("measurement/result")); Filter unrolled = (Filter) nullFilter.accept(visitor, null); assertTrue(unrolled instanceof PropertyIsNull); assertNotSame(nullFilter, unrolled); PropertyIsNull unmapped = (PropertyIsNull) unrolled; Expression unmappedAtt = unmapped.getExpression(); assertTrue(unmappedAtt instanceof PropertyName); assertEquals("results_value", ((PropertyName) unmappedAtt).getPropertyName()); }
@Test public void testTextSymbolizerPriority() throws Exception { String yaml = "text:\n" + " label: ${name}\n" + " priority: ${pop}\n" + ""; StyledLayerDescriptor sld = Ysld.parse(yaml); TextSymbolizer2 p = (TextSymbolizer2) SLD.textSymbolizer(SLD.defaultStyle(sld)); assertNotNull(p.getPriority()); assertTrue(p.getPriority() instanceof PropertyName); assertEquals("pop", ((PropertyName) p.getPriority()).getPropertyName()); }