@Override
protected SimpleFeatureType buildFeatureType() {
String[] headers;
Map<String, Class<?>> typesFromData;
CsvReader csvReader = null;
try {
csvReader = csvFileState.openCSVReader();
headers = csvReader.getHeaders();
typesFromData = CSVStrategy.findMostSpecificTypesFromData(csvReader, headers);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (csvReader != null) {
csvReader.close();
}
}
SimpleFeatureTypeBuilder builder =
CSVStrategy.createBuilder(csvFileState, headers, typesFromData);
Class<?> latClass = typesFromData.get(latField);
Class<?> lngClass = typesFromData.get(lngField);
if (CSVStrategy.isNumeric(latClass) && CSVStrategy.isNumeric(lngClass)) {
List<String> csvHeaders = Arrays.asList(headers);
int index = csvHeaders.indexOf(latField);
AttributeTypeBuilder builder2 = new AttributeTypeBuilder();
builder2.setCRS(DefaultGeographicCRS.WGS84);
builder2.binding(Point.class);
AttributeDescriptor descriptor = builder2.buildDescriptor(pointField);
builder.add(index, descriptor);
builder.remove(latField);
builder.remove(lngField);
}
return builder.buildFeatureType();
}
static AttributeDescriptor getIntersectionType(
SimpleFeatureCollection first, SimpleFeatureCollection second) {
Class firstGeomType = first.getSchema().getGeometryDescriptor().getType().getBinding();
Class secondGeomType = second.getSchema().getGeometryDescriptor().getType().getBinding();
// figure out the output geometry type
Class binding;
if (isGeometryTypeIn(secondGeomType, Point.class)) {
binding = Point.class;
} else if (isGeometryTypeIn(secondGeomType, MultiPoint.class)) {
binding = MultiPoint.class;
} else if (isGeometryTypeIn(secondGeomType, LineString.class, MultiLineString.class)) {
binding = MultiLineString.class;
} else if (isGeometryTypeIn(secondGeomType, Polygon.class, MultiPolygon.class)) {
if (isGeometryTypeIn(firstGeomType, Polygon.class, MultiPolygon.class)) {
binding = MultiPolygon.class;
} else {
binding = MultiLineString.class;
}
} else {
// we can't be more precise than this
binding = Geometry.class;
}
AttributeTypeBuilder builder = new AttributeTypeBuilder();
builder.setName("the_geom");
builder.setBinding(binding);
builder.setCRS(first.features().next().getFeatureType().getCoordinateReferenceSystem());
AttributeDescriptor descriptor = builder.buildDescriptor("the_geom");
return descriptor;
}
/**
* This method joins the feature type with the types maintained by this object. Geometry attribute
* is not added into the join geometry. It must be computed by the client and setted using the
* setGeometry Method.
*
* @see setGeometry
* @param featureType
*/
public FeatureTypeUnionBuilder add(final SimpleFeatureType featureType) {
// adds the attribute types of this feature type, if there are name
// collisions
// the method appends the number "2" at the name to avoid name
// duplication.
// The geometry attribute will be omitted.
for (int i = 0; i < featureType.getAttributeCount(); i++) {
AttributeDescriptor attributeType = featureType.getDescriptor(i);
if (!(attributeType instanceof GeometryDescriptor)) {
String attrUnionName = attributeType.getLocalName();
if (this.mapUnionAttributes.containsKey(attrUnionName)) {
StringBuffer duplicatedName = new StringBuffer(attrUnionName);
duplicatedName.append("2");
attrUnionName = duplicatedName.toString();
}
AttributeTypeBuilder builder = new AttributeTypeBuilder();
builder.setBinding(attributeType.getType().getBinding());
builder.setNillable(attributeType.isNillable());
AttributeDescriptor newAttribute = builder.buildDescriptor(attrUnionName);
mapUnionAttributes.put(attrUnionName, newAttribute);
mapOriginalUnion.put(
new UnionKey(featureType.getTypeName(), attributeType.getLocalName()), attrUnionName);
}
}
return this;
}
/**
* 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 void collectAttributes(
SimpleFeatureType schema, List<String> retainedAttributes, SimpleFeatureTypeBuilder tb) {
for (AttributeDescriptor descriptor : schema.getAttributeDescriptors()) {
// check whether descriptor has been selected in the attribute list
boolean isInRetainList = true;
if (retainedAttributes != null) {
isInRetainList = retainedAttributes.contains(descriptor.getLocalName());
logger.fine("Checking " + descriptor.getLocalName() + " --> " + isInRetainList);
}
if (!isInRetainList || schema.getGeometryDescriptor() == descriptor) {
continue;
}
// build the attribute to return
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());
}
}
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"));
return sftBuilder.buildFeatureType();
}
@Test
public void testCreateBasedOnShapeType() throws Exception {
TestEditBlackboard bb = new TestEditBlackboard();
String fid = "FeatureID";
EditGeom geom = bb.newGeom(fid, null);
bb.addPoint(10, 10, geom.getShell());
EditGeom geom2 = bb.newGeom(fid, null);
AttributeTypeBuilder builder = new AttributeTypeBuilder();
builder.setBinding(Geometry.class);
builder.setName("geom");
GeometryDescriptor at = builder.buildDescriptor("geom", builder.buildGeometryType());
bb.addPoint(100, 100, geom2.getShell());
String fid2 = "FID2";
EditGeom differentGeom = bb.newGeom(fid2, null);
bb.addPoint(200, 200, differentGeom.getShell());
Map<String, Bag> result = GeometryCreationUtil.createAllGeoms(geom, Point.class, at, false);
assertEquals(1, result.get(fid2).jts.size());
assertEquals(Point.class, result.get(fid2).jts.get(0).getClass());
differentGeom.setShapeType(ShapeType.LINE);
result = GeometryCreationUtil.createAllGeoms(geom, Point.class, at, false);
assertEquals(1, result.get(fid2).jts.size());
assertEquals(LineString.class, result.get(fid2).jts.get(0).getClass());
differentGeom.setShapeType(ShapeType.POLYGON);
result = GeometryCreationUtil.createAllGeoms(geom, Point.class, at, false);
assertEquals(1, result.get(fid2).jts.size());
assertEquals(Polygon.class, result.get(fid2).jts.get(0).getClass());
differentGeom.setShapeType(ShapeType.UNKNOWN);
result = GeometryCreationUtil.createAllGeoms(geom, Point.class, at, false);
assertEquals(1, result.get(fid2).jts.size());
assertEquals(Point.class, result.get(fid2).jts.get(0).getClass());
bb.addPoint(200, 200, differentGeom.getShell());
result = GeometryCreationUtil.createAllGeoms(geom, Point.class, at, false);
assertEquals(1, result.get(fid2).jts.size());
assertEquals(Point.class, result.get(fid2).jts.get(0).getClass());
bb.addPoint(200, 210, differentGeom.getShell());
result = GeometryCreationUtil.createAllGeoms(geom, Point.class, at, false);
assertEquals(1, result.get(fid2).jts.size());
assertEquals(LineString.class, result.get(fid2).jts.get(0).getClass());
bb.addPoint(200, 200, differentGeom.getShell());
result = GeometryCreationUtil.createAllGeoms(geom, Point.class, at, false);
assertEquals(1, result.get(fid2).jts.size());
assertEquals(Polygon.class, result.get(fid2).jts.get(0).getClass());
}
/**
* Builds a feature type from compiled state.
*
* <p>After the type is built the running list of attributes is cleared.
*
* @return The built feature type.
*/
public SimpleFeatureType buildFeatureType() {
GeometryDescriptor defGeom = null;
// was a default geometry set?
if (this.defaultGeometry != null) {
List<AttributeDescriptor> atts = attributes();
for (int i = 0; i < atts.size(); i++) {
AttributeDescriptor att = atts.get(i);
if (this.defaultGeometry.equals(att.getName().getLocalPart())) {
// ensure the attribute is a geometry attribute
//
if (!(att instanceof GeometryDescriptor)) {
LOGGER.warning("Default Geometry " + this.defaultGeometry + " was added as a geoemtry");
attributeBuilder.init(att);
attributeBuilder.setCRS(defaultCrs);
GeometryType type = attributeBuilder.buildGeometryType();
att = attributeBuilder.buildDescriptor(att.getName(), type);
atts.set(i, att);
}
defGeom = (GeometryDescriptor) att;
break;
}
}
if (defGeom == null) {
String msg =
"'"
+ this.defaultGeometry
+ " specified as default"
+ " but could find no such attribute.";
throw new IllegalArgumentException(msg);
}
}
if (defGeom == null) {
// none was set by name, look for first geometric type
for (AttributeDescriptor att : attributes()) {
if (att instanceof GeometryDescriptor) {
defGeom = (GeometryDescriptor) att;
break;
}
}
}
SimpleFeatureType built =
factory.createSimpleFeatureType(
name(), attributes(), defGeom, isAbstract, restrictions(), superType, description);
init();
return built;
}
public FeatureTypeUnionBuilder setGeometryClass(
final String geometryName,
final Class<? extends Geometry> geomClass,
final CoordinateReferenceSystem crs) {
assert geometryName != null : "the geometry name can not be null";
assert geomClass != null : "the geometry class can not be null";
assert crs != null : "the CRS can not be null";
this.geometryName = geometryName;
this.geometryClass = geomClass;
GeometryDescriptor geoAttrType;
AttributeTypeBuilder build = new AttributeTypeBuilder();
build.setName(this.geometryName);
build.setBinding(this.geometryClass);
build.setNillable(true);
build.setLength(100);
build.setCRS(crs);
GeometryType type = build.buildGeometryType();
geoAttrType = build.buildDescriptor(this.geometryName, type);
this.unionGeometryAttr = geoAttrType;
return this;
}
/**
* 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();
}
/**
* Create a SimpleFeatureType with the same content; just updating the geometry attribute to match
* the provided coordinate reference system.
*
* @param original SimpleFeatureType
* @param crs CoordinateReferenceSystem of result
* @return SimpleFeatureType updated with the provided CoordinateReferenceSystem
*/
public static SimpleFeatureType retype(
SimpleFeatureType original, CoordinateReferenceSystem crs) {
SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
// initialize the builder
b.init(original);
// clear the attributes
b.attributes().clear();
// add attributes in order
for (AttributeDescriptor descriptor : original.getAttributeDescriptors()) {
if (descriptor instanceof GeometryDescriptor) {
GeometryDescriptor geometryDescriptor = (GeometryDescriptor) descriptor;
AttributeTypeBuilder adjust = new AttributeTypeBuilder(b.factory);
adjust.init(geometryDescriptor);
adjust.setCRS(crs);
b.add(adjust.buildDescriptor(geometryDescriptor.getLocalName()));
continue;
}
b.add(descriptor);
}
return b.buildFeatureType();
}
/**
* Adds a new attribute w/ provided name and class.
*
* <p>The provided class is used to locate an attribute type binding previously specified by
* {@link #addBinding(AttributeType)},{@link #addBindings(Schema)}, or {@link
* #setBindings(Schema)}.
*
* <p>If not such binding exists then an attribute type is created on the fly.
*
* @param name The name of the attribute.
* @param bind The class the attribute is bound to.
*/
public void add(String name, Class<?> binding) {
AttributeDescriptor descriptor = null;
attributeBuilder.setBinding(binding);
attributeBuilder.setName(name);
// check if this is the name of the default geometry, in that case we
// better make it a geometry type
// also check for jts geometry, if we ever actually get to a point where a
// feature can be backed by another geometry model (like iso), we need
// to remove this check
//
if ((defaultGeometry != null && defaultGeometry.equals(name))
|| Geometry.class.isAssignableFrom(binding)) {
// if no crs was set, set to defaultCRS
if (!attributeBuilder.isCRSSet()) {
if (defaultCrs == null && !defaultCrsSet) {
LOGGER.fine(
"Creating "
+ name
+ " with null CoordinateReferenceSystem - did you mean to setCRS?");
}
attributeBuilder.setCRS(defaultCrs);
}
GeometryType type = attributeBuilder.buildGeometryType();
descriptor = attributeBuilder.buildDescriptor(name, type);
} else {
AttributeType type = attributeBuilder.buildType();
descriptor = attributeBuilder.buildDescriptor(name, type);
}
attributes().add(descriptor);
}
public static SimpleFeatureType createSubType(
SimpleFeatureType featureType,
String[] properties,
CoordinateReferenceSystem override,
String typeName,
URI namespace)
throws SchemaException {
if ((properties == null) && (override == null)) {
return featureType;
}
if (properties == null) {
properties = new String[featureType.getAttributeCount()];
for (int i = 0; i < properties.length; i++) {
properties[i] = featureType.getDescriptor(i).getLocalName();
}
}
String namespaceURI = namespace != null ? namespace.toString() : null;
boolean same =
featureType.getAttributeCount() == properties.length
&& featureType.getTypeName().equals(typeName)
&& Utilities.equals(featureType.getName().getNamespaceURI(), namespaceURI);
for (int i = 0; (i < featureType.getAttributeCount()) && same; i++) {
AttributeDescriptor type = featureType.getDescriptor(i);
same =
type.getLocalName().equals(properties[i])
&& (((override != null) && type instanceof GeometryDescriptor)
? assertEquals(
override, ((GeometryDescriptor) type).getCoordinateReferenceSystem())
: true);
}
if (same) {
return featureType;
}
AttributeDescriptor[] types = new AttributeDescriptor[properties.length];
for (int i = 0; i < properties.length; i++) {
types[i] = featureType.getDescriptor(properties[i]);
if ((override != null) && types[i] instanceof GeometryDescriptor) {
AttributeTypeBuilder ab = new AttributeTypeBuilder();
ab.init(types[i]);
ab.setCRS(override);
types[i] = ab.buildDescriptor(types[i].getLocalName(), ab.buildGeometryType());
}
}
if (typeName == null) typeName = featureType.getTypeName();
if (namespace == null && featureType.getName().getNamespaceURI() != null)
try {
namespace = new URI(featureType.getName().getNamespaceURI());
} catch (URISyntaxException e) {
throw new RuntimeException(e);
}
SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
tb.setName(typeName);
tb.setNamespaceURI(namespace);
tb.addAll(types);
return tb.buildFeatureType();
}
/**
* Replace the descriptor at the provided index.
*
* @param index
* @param descriptor
*/
public void set(String attributeName, AttributeTypeBuilder attributeBuilder) {
AttributeDescriptor descriptor = attributeBuilder.buildDescriptor(attributeName);
set(attributeName, descriptor);
}
/**
* Sets the maxOccurs of the next attribute added to the feature type.
*
* <p>This value is reset after a call to {@link #add(String, Class)}
*/
public SimpleFeatureTypeBuilder maxOccurs(int maxOccurs) {
attributeBuilder.setMaxOccurs(maxOccurs);
return this;
}
/**
* Sets a restriction on the field length of the next attribute added to the feature type.
*
* <p>This method is the same as adding a restriction based on length( value ) < length This value
* is reset after a call to {@link #add(String, Class)}
*
* @return length Used to limit the length of the next attribute created
*/
public SimpleFeatureTypeBuilder length(int length) {
attributeBuilder.setLength(length);
return this;
}
/**
* Sets user data for the next attribute added to the feature type.
*
* <p>This value is reset after a call to {@link #add(String, Class)}
*
* @param key The key of the user data.
* @param value The value of the user data.
*/
public SimpleFeatureTypeBuilder userData(Object key, Object value) {
attributeBuilder.addUserData(key, value);
return this;
}
/**
* Sets the crs of the next attribute added to the feature type.
*
* <p>This only applies if the attribute added is geometric. Example: <code>
* builder.crs( DefaultGeographicCRS.WGS84 ).add( "geom", Polygon.class )</code>
*
* <p>This value is reset after a call to {@link #add(String, Class)}
*/
public SimpleFeatureTypeBuilder crs(CoordinateReferenceSystem crs) {
attributeBuilder.setCRS(crs);
return this;
}
/**
* Sets the description of the next attribute added to the feature type.
*
* <p>This value is reset after a call to {@link #add(String, Class)}
*/
public SimpleFeatureTypeBuilder description(String description) {
attributeBuilder.setDescription(description);
return this;
}
/**
* Adds a collection of restrictions to the next attribute added to the
*
* <p>This value is reset after a call to {@link #add(String, Class)}
*/
public SimpleFeatureTypeBuilder restrictions(List<Filter> filters) {
for (Filter f : filters) {
attributeBuilder.addRestriction(f);
}
return this;
}
/**
* Adds a restriction to the next attribute added to the feature type.
*
* <p>This value is reset after a call to {@link #add(String, Class)}
*/
public SimpleFeatureTypeBuilder restriction(Filter filter) {
attributeBuilder.addRestriction(filter);
return this;
}
/**
* Sets the default value of the next attribute added to the feature type.
*
* <p>This value is reset after a call to {@link #add(String, Class)}
*/
public SimpleFeatureTypeBuilder defaultValue(Object defaultValue) {
attributeBuilder.setDefaultValue(defaultValue);
return this;
}
/**
* Sets the nullability of the next attribute added to the feature type.
*
* <p>This value is reset after a call to {@link #add(String, Class)}
*/
public SimpleFeatureTypeBuilder nillable(boolean isNillable) {
attributeBuilder.setNillable(isNillable);
return this;
}