SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); for (AttributeDescriptor descriptor : delegate.getSchema().getAttributeDescriptors()) { if (sameNames(features.getSchema(), descriptor) && !sameTypes(features.getSchema(), descriptor)) { AttributeTypeBuilder builder = new AttributeTypeBuilder(); builder.setName(descriptor.getLocalName()); builder.setNillable(descriptor.isNillable()); builder.setBinding(String.class); builder.setMinOccurs(descriptor.getMinOccurs()); builder.setMaxOccurs(descriptor.getMaxOccurs()); builder.setDefaultValue(descriptor.getDefaultValue()); builder.setCRS( this.delegate .features() .next() .getFeatureType() .getCoordinateReferenceSystem()); AttributeDescriptor attributeDescriptor = builder.buildDescriptor(descriptor.getName(), builder.buildType()); tb.add(attributeDescriptor); } else { tb.add(descriptor); for (AttributeDescriptor descriptor : features.getSchema().getAttributeDescriptors()) { if (!sameNames(delegate.getSchema(), descriptor) && !sameTypes(delegate.getSchema(), descriptor)) {
/** * Recursively scans a SimpleFeature for SimpleFeature attributes in order to build a * "flattened" list of attributes * * @param attributeDescriptors A List of attribute descriptors, populated recursively * @param featuretype The feature type to scan * @param attrAlias An alias for adding as a prefix to the simple attribute names */ private static void scanAttributeDescriptors( List<AttributeDescriptor> attributeDescriptors, SimpleFeatureType featureType, String attrAlias) { List<AttributeDescriptor> descriptors = featureType.getAttributeDescriptors(); for (int i = 0; i < descriptors.size(); i++) { AttributeDescriptor ad = descriptors.get(i); SimpleFeatureType joinedSchema = (SimpleFeatureType) ad.getUserData().get(ContentDataStore.JOINED_FEATURE_TYPE); String name = (attrAlias != null ? attrAlias + "." : "") + ad.getLocalName(); if (joinedSchema != null) { // go forth and harvest feature attribute types scanAttributeDescriptors(attributeDescriptors, joinedSchema, name); } else { // this is a common (non-feature) attribute type AttributeTypeBuilder build = new AttributeTypeBuilder(); build.init(ad); AttributeDescriptor descriptor = build.buildDescriptor(name); attributeDescriptors.add(descriptor); } } }
AttributeTypeBuilder b = new AttributeTypeBuilder(); b.init(old); b.setCRS(getCRS(info.getSRS())); ad = b.buildDescriptor(old.getLocalName());
/** * Adds a new geometric attribute w/ provided name, class, and coordinate reference system. * * <p>The <tt>crs</tt> parameter may be <code>null</code>. * * @param name The name of the attribute. * @param binding The class that the attribute is bound to. * @param crs The crs of of the geometry, may be <code>null</code>. */ public void add(String name, Class<?> binding, CoordinateReferenceSystem crs) { attributeBuilder.setBinding(binding); attributeBuilder.setName(name); attributeBuilder.setCRS(crs); GeometryType type = attributeBuilder.buildGeometryType(); GeometryDescriptor descriptor = attributeBuilder.buildDescriptor(name, type); attributes().add(descriptor); }
private static SimpleFeatureType getPointSimpleFeatureType() { final String NAME = "PointSimpleFeatureType"; final SimpleFeatureTypeBuilder sftBuilder = new SimpleFeatureTypeBuilder(); final AttributeTypeBuilder atBuilder = new AttributeTypeBuilder(); sftBuilder.setName(NAME); sftBuilder.add(atBuilder.binding(String.class).nillable(false).buildDescriptor("locationName")); sftBuilder.add(atBuilder.binding(Geometry.class).nillable(false).buildDescriptor("geometry")); sftBuilder.add(atBuilder.binding(Date.class).nillable(false).buildDescriptor("startTime")); sftBuilder.add(atBuilder.binding(Date.class).nillable(false).buildDescriptor("endTime")); return sftBuilder.buildFeatureType(); }
@Override protected SimpleFeatureType buildTargetFeatureType() { // create schema SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); for (AttributeDescriptor descriptor : delegate.getSchema().getAttributeDescriptors()) { if (!(descriptor.getType() instanceof GeometryTypeImpl) || (!delegate.getSchema().getGeometryDescriptor().equals(descriptor))) { tb.add(descriptor); } else { AttributeTypeBuilder builder = new AttributeTypeBuilder(); builder.setBinding(MultiPolygon.class); AttributeDescriptor attributeDescriptor = builder.buildDescriptor(descriptor.getLocalName(), builder.buildType()); tb.add(attributeDescriptor); if (tb.getDefaultGeometry() == null) { tb.setDefaultGeometry(descriptor.getLocalName()); } } } tb.setDescription(delegate.getSchema().getDescription()); tb.setCRS(delegate.getSchema().getCoordinateReferenceSystem()); tb.setName(delegate.getSchema().getName()); return tb.buildFeatureType(); }
public SimpleFeatureType convertType(SimpleFeatureType featureType, VectorFormat format, ImportData data, ImportTask task) { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName(convertTypeName(featureType.getTypeName())); AttributeTypeBuilder attBuilder = new AttributeTypeBuilder(); for (AttributeDescriptor att : featureType.getAttributeDescriptors()) { attBuilder.init(att); typeBuilder.add(attBuilder.buildDescriptor(convertAttributeName(att.getLocalName()))); } return typeBuilder.buildFeatureType(); }
properties = new String[featureType.getAttributeCount()]; for (int i = 0; i < properties.length; i++) { properties[i] = featureType.getDescriptor(i).getLocalName(); featureType.getAttributeCount() == properties.length && featureType.getTypeName().equals(typeName) && Utilities.equals(featureType.getName().getNamespaceURI(), namespaceURI); AttributeDescriptor type = featureType.getDescriptor(i); same = type.getLocalName().equals(properties[i]) && (((override != null) && type instanceof GeometryDescriptor) ? assertEquals( AttributeTypeBuilder ab = new AttributeTypeBuilder(); ab.init(types[i]); ab.setCRS(override); types[i] = ab.buildDescriptor(types[i].getLocalName(), ab.buildGeometryType()); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setName(typeName); tb.setNamespaceURI(namespace); tb.setCRS(null); // not interested in warnings from this simple method tb.addAll(types);
/** * Copys a feature type. * * <p>This method does a deep copy in that all individual attributes are copied as well. */ public static SimpleFeatureType copy(SimpleFeatureType original) { SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder(); // initialize the builder b.init(original); // clear attributes b.attributes().clear(); // add attributes in order for (AttributeDescriptor descriptor : original.getAttributeDescriptors()) { AttributeTypeBuilder ab = new AttributeTypeBuilder(b.factory); ab.init(descriptor); b.add(ab.buildDescriptor(descriptor.getLocalName())); } return b.buildFeatureType(); } }
List<String> retainedAttributes, SimpleFeatureTypeBuilder tb) { for (AttributeDescriptor descriptor : schema.getAttributeDescriptors()) { isInRetainList = retainedAttributes.contains(descriptor.getLocalName()); logger.fine("Checking " + descriptor.getLocalName() + " --> " + isInRetainList); if (!isInRetainList || schema.getGeometryDescriptor() == descriptor) { continue; AttributeTypeBuilder builder = new AttributeTypeBuilder(); builder.setName(schema.getName().getLocalPart() + "_" + descriptor.getName()); builder.setNillable(descriptor.isNillable()); builder.setBinding(descriptor.getType().getBinding()); builder.setMinOccurs(descriptor.getMinOccurs()); builder.setMaxOccurs(descriptor.getMaxOccurs()); builder.setDefaultValue(descriptor.getDefaultValue()); builder.setCRS(schema.getCoordinateReferenceSystem()); AttributeDescriptor intersectionDescriptor = builder.buildDescriptor( schema.getName().getLocalPart() + "_" + descriptor.getName(), descriptor.getType()); tb.add(intersectionDescriptor); tb.addBinding(descriptor.getType());
public static SimpleFeatureType createPlainFeatureType(String typeName, Class<? extends Geometry> geometryType, CoordinateReferenceSystem crs) { SimpleFeatureTypeBuilder sftb = new SimpleFeatureTypeBuilder(); AttributeTypeBuilder atb = new AttributeTypeBuilder(); if (crs != null) { atb.setCRS(crs); } atb.setBinding(geometryType); atb.nillable(false); sftb.add(atb.buildDescriptor(ATTRIB_NAME_GEOMETRY)); sftb.setDefaultGeometry(ATTRIB_NAME_GEOMETRY); atb.setBinding(String.class); atb.nillable(true); sftb.add(atb.buildDescriptor(ATTRIB_NAME_STYLE_CSS)); sftb.setName(typeName); return sftb.buildFeatureType(); }
private SimpleFeatureType buildShcema(SimpleFeatureType featureType, CoordinateReferenceSystem crs, String typeName) { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName(getName(typeName)); typeBuilder.setCRS(crs); AttributeTypeBuilder attBuilder = new AttributeTypeBuilder(); List<AttributeDescriptor> attDescs = featureType.getAttributeDescriptors(); for (AttributeDescriptor descriptor : attDescs) { if (descriptor instanceof GeometryDescriptor) { final GeometryDescriptor geomDesc = (GeometryDescriptor) descriptor; final Class<?> geomBinding = geomDesc.getType().getBinding(); typeBuilder.add(getName(geomDesc.getLocalName()), geomBinding, crs); } else { final String localName = getName(descriptor.getLocalName()); if (localName.equalsIgnoreCase("shape_leng") || localName.equalsIgnoreCase("shape_area")) { continue; } else { typeBuilder.add(attBuilder.buildDescriptor(localName, descriptor.getType())); } } } return typeBuilder.buildFeatureType(); }
public SimpleFeatureType apply(ImportTask task, DataStore dataStore, SimpleFeatureType featureType) throws Exception { //remap the type SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.init(featureType); int index = featureType.indexOf(field); if (index < 0) { throw new Exception("FeatureType " + featureType.getName() + " does not have attribute named '" + field + "'"); } //remap the attribute to type date and ensure schema ordering is the same //@todo improve FeatureTypeBuilder to support this directly AttributeDescriptor existing = builder.remove(field); AttributeTypeBuilder attBuilder = new AttributeTypeBuilder(); attBuilder.init(existing); attBuilder.setBinding(type); builder.add(index, attBuilder.buildDescriptor(field)); return builder.buildFeatureType(); }
VirtualTable virtualTable = getDataStore().getVirtualTables().get(entry.getTypeName()); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); AttributeTypeBuilder ab = new AttributeTypeBuilder(); tb.setName(tableName); ab.addUserData(JDBCDataStore.JDBC_NATIVE_TYPENAME, column.typeName); ab.addUserData(JDBCDataStore.JDBC_NATIVE_TYPE, column.sqlType); ab.nillable(false); ab.minOccurs(1); ab.setBinding(binding); ab.setName(name); ab.setCRS(crs); if (srid != null) { ab.addUserData(JDBCDataStore.JDBC_NATIVE_SRID, srid); ab.addUserData(Hints.COORDINATE_DIMENSION, dimension); att = ab.buildDescriptor(name, ab.buildGeometryType()); } else { ab.setName(name); ab.setBinding(binding); att = ab.buildDescriptor(name, ab.buildType()); ft.getUserData().put(JDBCDataStore.JDBC_READ_ONLY, Boolean.TRUE);
protected SimpleFeatureType getFeatureType(SimpleFeatureType origType, JoiningQuery query) throws IOException { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.init(origType); AttributeTypeBuilder ab = new AttributeTypeBuilder(); if (query.getQueryJoins() != null) { for (int i = 0; i < query.getQueryJoins().size(); i++) { for (PrimaryKeyColumn col : joinKey.getColumns()) { query.getQueryJoins().get(i).addId(col.getName()); ab.setBinding(String.class); builder.add( ab.buildDescriptor( new NameImpl(FOREIGN_ID) + "_" + i + "_" + j, ab.buildType())); j++; ab.setBinding(String.class); builder.add( ab.buildDescriptor( new NameImpl(FOREIGN_ID) + "_" + i + "_" + 0, ab.buildType())); ab.setBinding(String.class); builder.add(ab.buildDescriptor(PRIMARY_KEY + "_" + j, ab.buildType()));
@Override protected void connect() throws Exception { super.connect(); // we need to use the type builder because the pk has min occurs = 1 on Oracle AttributeTypeBuilder atb = new AttributeTypeBuilder(); atb.setMinOccurs(isPkNillable() ? 0 : 1); atb.setMaxOccurs(1); atb.setNillable(isPkNillable()); atb.setName(FID); atb.setBinding(Integer.class); AttributeDescriptor fidDescriptor = atb.buildDescriptor(FID); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setNamespaceURI(dataStore.getNamespaceURI()); tb.setName(LAKESVIEW); tb.add(fidDescriptor); tb.add(ID, Integer.class); tb.add(GEOM, Polygon.class, (CoordinateReferenceSystem) null); tb.add(NAME, String.class); lakeViewSchema = tb.buildFeatureType(); lakeViewPkSchema = tb.retype(lakeViewSchema, new String[] {ID, GEOM, NAME}); }
AttributeTypeBuilder b = new AttributeTypeBuilder(); b.setName(name); b.setBinding(typeClass); b.setNillable(defa == null); b.setDefaultValue(defa); columns[i] = b.buildDescriptor(name); AttributeTypeBuilder b = new AttributeTypeBuilder(); b.setName(geometryName); b.setBinding(geomType); b.setNillable(true); columns[0] = b.buildDescriptor(geometryName); typeName = typeName.substring(0, typeName.indexOf(".")); SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName(typeName); builder.setNamespaceURI(namespace); b = new AttributeTypeBuilder(); b.setName("MIF_TEXT"); b.setBinding(String.class); b.setNillable(true); builder.add(b.buildDescriptor("MIF_TEXT"));
public static SimpleFeatureType convert(DBObject ftDBO, Name name) { SimpleFeatureTypeBuilder ftBuilder = new SimpleFeatureTypeBuilder(); AttributeTypeBuilder atBuilder = new AttributeTypeBuilder(); String bindingName = extractString(extractDBObject(adDBO, KEY_type), KEY_binding); try { atBuilder.binding(Class.forName(bindingName)); } catch (ClassNotFoundException ex) { throw new RuntimeException( if (adUserDataDBO != null) { for (Map.Entry<?, ?> entry : ((Map<?, ?>) adUserDataDBO.toMap()).entrySet()) { atBuilder.userData(entry.getKey(), entry.getValue()); atBuilder.crs(crs); ftBuilder.add( atBuilder.buildDescriptor(adLocalName, atBuilder.buildGeometryType())); } else { Integer min = extractInteger(adDBO, KEY_minOccurs, false); if (min != null) { atBuilder.minOccurs(min); atBuilder.maxOccurs(max); atBuilder.defaultValue(dv); ftBuilder.add(atBuilder.buildDescriptor(adLocalName));
SimpleFeatureType buildFeatureTypeWithXMLUnsafeAtts() { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName("badatts"); AttributeTypeBuilder attBuilder = new AttributeTypeBuilder(); attBuilder.setBinding(String.class); typeBuilder.add(attBuilder.buildDescriptor("123_number_first")); attBuilder.setBinding(String.class); typeBuilder.add(attBuilder.buildDescriptor("i has spaces")); return typeBuilder.buildFeatureType(); }
private static GeometryDescriptor handleGeometryAttribute(SimpleFeatureType schema, CoordinateReferenceSystem crs, SimpleFeatureTypeBuilder factory, GeometryDescriptor defaultGeometryType, AttributeDescriptor attributeType) { GeometryDescriptor geometryType = (GeometryDescriptor) attributeType; GeometryDescriptor geometry; AttributeTypeBuilder builder = new AttributeTypeBuilder(); builder.setName(geometryType.getLocalName()); builder.setBinding(geometryType.getType().getBinding()); builder.setNillable(geometryType.isNillable()); // builder.setDefaultValue(defaultValue); builder.setCRS(crs); geometry = builder .buildDescriptor(geometryType.getLocalName(), builder.buildGeometryType()); if (defaultGeometryType == null || geometryType == schema.getGeometryDescriptor()) { defaultGeometryType = geometry; } factory.add(geometry); return defaultGeometryType; }