@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);
  }
示例#13
0
  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;
 }