/** * Provides a defautlValue for attributeType. * * <p>Will return null if attributeType isNillable(), or attempt to use Reflection, or * attributeType.parse( null ) * * @param attributeType * @return null for nillable attributeType, attempt at reflection * @deprecated Please {@link AttributeDescriptor#getDefaultValue()} */ public static Object defaultValue(AttributeDescriptor attributeType) throws IllegalAttributeException { Object value = attributeType.getDefaultValue(); if (value == null && !attributeType.isNillable()) { return null; // sometimes there is no valid default value :-( } return value; }
value.add( new GeometryAttributeImpl( ((AttributeDescriptor) pd).getDefaultValue(), (GeometryDescriptor) pd, null)); value.add( new AttributeImpl( ((AttributeDescriptor) pd).getDefaultValue(), (AttributeDescriptor) pd, null));
/** * Create default values matching the provided feature type. * * @param featureType * @param values * @return set of default values * @throws ArrayIndexOutOfBoundsException If the number of provided values does not match the * featureType */ public static Object[] defaultValues(SimpleFeatureType featureType, Object[] values) { if (values == null) { values = new Object[featureType.getAttributeCount()]; } else if (values.length != featureType.getAttributeCount()) { throw new ArrayIndexOutOfBoundsException("values"); } for (int i = 0; i < featureType.getAttributeCount(); i++) { AttributeDescriptor descriptor = featureType.getDescriptor(i); values[i] = descriptor.getDefaultValue(); } return values; }
if (value == null) { if (descriptor.isNillable()) { return descriptor.getDefaultValue();
/** * Builds a new feature whose attribute values are the default ones * * @param featureType * @param featureId * @return */ public static SimpleFeature template(SimpleFeatureType featureType, String featureId) { SimpleFeatureBuilder builder = new SimpleFeatureBuilder(featureType); for (AttributeDescriptor ad : featureType.getAttributeDescriptors()) { builder.add(ad.getDefaultValue()); } return builder.buildFeature(featureId); }
private Object convert(Object value, AttributeDescriptor descriptor) { if (value == null) { // if the content is null and the descriptor says isNillable is false, // then set the default value if (!descriptor.isNillable()) { value = descriptor.getDefaultValue(); if (value == null) { // no default value, try to generate one value = DataUtilities.defaultValue(descriptor.getType().getBinding()); } } } else { // make sure the type of the value and the binding of the type match up value = super.convert(value, descriptor); } return value; }
public NonFeatureTypeProxy( final AttributeType type, final FeatureTypeMapping mapping, Collection<PropertyDescriptor> schema) { super(type.getName(), null); subject = type; AttributeDescriptor originalTarget = mapping.getTargetFeature(); int maxOccurs = originalTarget.getMaxOccurs(); int minOccurs = originalTarget.getMinOccurs(); boolean nillable = originalTarget.isNillable(); Object defaultValue = originalTarget.getDefaultValue(); Name name = originalTarget.getName(); // create a new descriptor with the wrapped type and set it to the mapping ComplexFeatureTypeFactoryImpl typeFactory = new ComplexFeatureTypeFactoryImpl(); AttributeDescriptor descriptor = typeFactory.createAttributeDescriptor( this, name, minOccurs, maxOccurs, nillable, defaultValue); descriptor.getUserData().putAll(originalTarget.getUserData()); mapping.setTargetFeature(descriptor); // smuggle FEATURE_LINK descriptor schema.add(ComplexFeatureConstants.FEATURE_CHAINING_LINK); this.descriptors = schema; }
/** * Create a complex attribute for XS.AnyType, since it's defined as a simple type. We need a * complex attribute so we can set xlink:href in it. * * @param value * @param descriptor * @param id * @return */ public Attribute addComplexAnyTypeAttribute( Object value, AttributeDescriptor descriptor, String id) { // need to create a complex attribute for any type, so we can have client properties // for xlink:href and so we chain features etc. Map<Object, Object> userData = descriptor.getUserData(); descriptor = new AttributeDescriptorImpl( ANYTYPE_TYPE, descriptor.getName(), descriptor.getMinOccurs(), descriptor.getMaxOccurs(), descriptor.isNillable(), descriptor.getDefaultValue()); descriptor.getUserData().putAll(userData); return createComplexAttribute(value, ANYTYPE_TYPE, descriptor, id); }
private AttributeDescriptor reprojectAttribute(AttributeDescriptor descr) { if (reprojection != null && descr.getType() instanceof FeatureType) { AttributeDescriptor ad = ftf.createAttributeDescriptor( reprojectType((FeatureType) descr.getType()), descr.getName(), descr.getMinOccurs(), descr.getMaxOccurs(), descr.isNillable(), descr.getDefaultValue()); ad.getUserData().putAll(descr.getUserData()); return ad; } else { return descr; } }
DBObject adDBO = new BasicDBObject(KEY_localName, adLocalName); if (!adLocalName.equals(gdLocalName)) { Object dv = ad.getDefaultValue(); if (dv != null) { adDBO.put(KEY_defaultValue, dv);
descriptor.getMaxOccurs(), descriptor.isNillable(), descriptor.getDefaultValue());
int minOccurs = originalTarget.getMinOccurs(); boolean nillable = originalTarget.isNillable(); Object defaultValue = originalTarget.getDefaultValue(); Name name = originalTarget.getName();
/** * Sets all the attribute specific state from a single descriptor. * * <p>This method is convenience for: <code> * builder.minOccurs( descriptor.getMinOccurs() ).maxOccurs( descriptor.getMaxOccurs() ) * .nillable( descriptor.isNillable() )... * </code> */ public SimpleFeatureTypeBuilder descriptor(AttributeDescriptor descriptor) { minOccurs(descriptor.getMinOccurs()); maxOccurs(descriptor.getMaxOccurs()); nillable(descriptor.isNillable()); // namespaceURI( descriptor.getName().getNamespaceURI() ); defaultValue(descriptor.getDefaultValue()); if (descriptor instanceof GeometryDescriptor) { crs(((GeometryDescriptor) descriptor).getCoordinateReferenceSystem()); } return this; }
private AttributeDescriptor override(AttributeDescriptor type, AttributeDescriptor override) { int max = override.getMaxOccurs(); if (max < 0) max = type.getMinOccurs(); int min = override.getMinOccurs(); if (min < 0) min = type.getMinOccurs(); String name = override.getLocalName(); if (name == null) name = type.getLocalName(); List restrictions = override(type.getType().getRestrictions(), override.getType().getRestrictions()); Class javaType = override.getType().getBinding(); if (javaType == null) javaType = type.getType().getBinding(); boolean isNilable = override.isNillable(); Object defaultValue = override.getDefaultValue(); if (defaultValue == null) defaultValue = type.getDefaultValue(); // WARNING cannot copy metadata! return new AttributeDescriptorImpl( new AttributeTypeImpl( new NameImpl(name), javaType, false, false, restrictions, null, null), new NameImpl(name), min, max, isNilable, defaultValue); }
/** * Checkes the two feature types are equal, taking into consideration the eventual modification * the datastore had to perform in order to actually manage the type (change in names case, for * example) */ protected void assertAttributesEqual(AttributeDescriptor expected, AttributeDescriptor actual) { assertEquals(aname(expected.getName()), actual.getName()); assertEquals(expected.getMinOccurs(), actual.getMinOccurs()); assertEquals(expected.getMaxOccurs(), actual.getMaxOccurs()); assertEquals(expected.isNillable(), actual.isNillable()); assertEquals(expected.getDefaultValue(), actual.getDefaultValue()); AttributeType texpected = expected.getType(); AttributeType tactual = actual.getType(); if (Number.class.isAssignableFrom(texpected.getBinding())) { assertTrue(Number.class.isAssignableFrom(tactual.getBinding())); } else if (Geometry.class.isAssignableFrom(texpected.getBinding())) { assertTrue(Geometry.class.isAssignableFrom(tactual.getBinding())); } else { assertTrue(texpected.getBinding().isAssignableFrom(tactual.getBinding())); } }
public void testAttributeDefaultValue() { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName("buggy"); builder.nillable(false).defaultValue(12).add("attrWithDefault", Integer.class); builder.nillable(true).defaultValue(null).add("attrWithoutDefault", Integer.class); SimpleFeatureType featureType = builder.buildFeatureType(); assertFalse(featureType.getDescriptor("attrWithDefault").isNillable()); assertEquals(12, featureType.getDescriptor("attrWithDefault").getDefaultValue()); assertTrue(featureType.getDescriptor("attrWithoutDefault").isNillable()); assertNull(featureType.getDescriptor("attrWithoutDefault").getDefaultValue()); }
builder.setMinOccurs(descriptor.getMinOccurs()); builder.setMaxOccurs(descriptor.getMaxOccurs()); builder.setDefaultValue(descriptor.getDefaultValue()); builder.setCRS(schema.getCoordinateReferenceSystem()); AttributeDescriptor intersectionDescriptor =
void assertEqualsLax(SimpleFeatureType e, SimpleFeatureType a) { if (e.equals(a)) { return; } // do a lax check assertEquals(e.getAttributeCount(), a.getAttributeCount()); for (int i = 0; i < e.getAttributeCount(); i++) { AttributeDescriptor att1 = e.getDescriptor(i); AttributeDescriptor att2 = a.getDescriptor(i); assertEquals(att1.getName(), att2.getName()); assertEquals(att1.getMinOccurs(), att2.getMinOccurs()); assertEquals(att1.getMaxOccurs(), att2.getMaxOccurs()); assertEquals(att1.isNillable(), att2.isNillable()); assertEquals(att1.getDefaultValue(), att2.getDefaultValue()); AttributeType t1 = att1.getType(); AttributeType t2 = att2.getType(); assertEquals(t1.getName(), t2.getName()); assertEquals(t1.getDescription(), t2.getDescription()); assertEquals(t1.getRestrictions(), t2.getRestrictions()); // be a bit lax on type mappings if (!t1.getBinding().equals(t2.getBinding())) { if (Number.class.isAssignableFrom(t1.getBinding())) { assertTrue(Number.class.isAssignableFrom(t2.getBinding())); } if (Date.class.isAssignableFrom(t2.getBinding())) { assertTrue(Date.class.isAssignableFrom(t2.getBinding())); } } } }
builder.setMinOccurs(descriptor.getMinOccurs()); builder.setMaxOccurs(descriptor.getMaxOccurs()); builder.setDefaultValue(descriptor.getDefaultValue()); builder.setCRS( this.delegate
public void testAttributeBuilder() { FilterFactory ff = CommonFactoryFinder.getFilterFactory(); AttributeTypeBuilder builder = new AttributeTypeBuilder(); builder.binding(Integer.class); builder.minOccurs(1).maxOccurs(1); builder.defaultValue(0); builder.name("percent").description("Percent between 0 and 100"); builder.restriction(ff.greaterOrEqual(ff.property("."), ff.literal(0))) .restriction(ff.lessOrEqual(ff.property("."), ff.literal(100))); final AttributeType PERCENT = builder.buildType(); builder.minOccurs(1).maxOccurs(1); builder.defaultValue(0); builder.name("percent").description("Percent between 0 and 100"); AttributeDescriptor a = builder.buildDescriptor("a", PERCENT); assertSame(a.getType(), PERCENT); assertEquals(a.getDefaultValue(), 0); Filter restrictions = ff.and(PERCENT.getRestrictions()); assertTrue(restrictions.evaluate(50)); assertFalse(restrictions.evaluate(150)); }