Examples of org.geotools.feature.simple.SimpleFeatureBuilder

org.geotools.feature.simple.SimpleFeatureBuilder
of features we would like to build ( assume schema = (geom:Point,name:String) ) SimpleFeatureType featureType = ... //create the builder SimpleFeatureBuilder builder = new SimpleFeatureBuilder(); //set the type of created features builder.setType( featureType ); //add the attributes builder.add( new Point( 0 , 0 ) ); builder.add( "theName" ); //build the feature SimpleFeature feature = builder.buildFeature( "fid" );

This builder builds a feature by maintaining state. Each call to {@link #add(Object)}creates a new attribute for the feature and stores it locally. When using the add method to add attributes to the feature, values added must be added in the same order as the attributes as defined by the feature type. The methods {@link #set(String,Object)} and {@link #set(int,Object)} are used to add attributes out of order.

Each time the builder builds a feature with a call to {@link #buildFeature(String)}the internal state is reset.

This builder can be used to copy features as well. The following code sample demonstrates:
```
 //original feature SimpleFeature original = ...; //create and initialize the builder SimpleFeatureBuilder builder = new SimpleFeatureBuilder(); builder.init(original); //create the new feature SimpleFeature copy = builder.buildFeature( original.getID() ); 
```
The builder also provides a number of static "short-hand" methods which can be used when its not ideal to instantiate a new builder, thought this will trigger some extra object allocations. In time critical code sections it's better to instantiate the builder once and use it to build all the required features.
```
 SimpleFeatureType type = ..; Object[] values = ...; //build a new feature SimpleFeature feature = SimpleFeatureBuilder.build( type, values, "fid" ); ... SimpleFeature original = ...; //copy the feature SimpleFeature feature = SimpleFeatureBuilder.copy( original ); 
```
This class is not thread safe nor should instances be shared across multiple threads.
@author Justin Deoliveira @author Jody Garnett @source $URL$

        ArrayList<Coordinate> coords = Lists.newArrayList(((Geometry) values.get(2).get())
                .getCoordinates());
        coords.add(new Coordinate(0, 1));
        assertEquals(31347480l, values.get(0).get());
        GeometryFactory gf = new GeometryFactory();
        SimpleFeatureBuilder fb = new SimpleFeatureBuilder((SimpleFeatureType) featureType.get()
                .type());
        fb.set("geom", gf.createLineString(coords.toArray(new Coordinate[0])));
        fb.set("name", "newname");
        fb.set("id", 31347480l);
        fb.set("nodes", values.get(3).get());
        SimpleFeature newFeature = fb.buildFeature("31347480");
        geogig.getRepository().workingTree().insert("residential", newFeature);
        Optional<RevFeature> mapped = geogig.command(RevObjectParse.class)
                .setRefSpec("WORK_HEAD:residential/31347480").call(RevFeature.class);
        assertTrue(mapped.isPresent());
        values = mapped.get().getValues();

View Full Code Here

                    .call(RevFeature.class).get();
            RevFeatureType revFeatureType = command(RevObjectParse.class)
                    .setObjectId(node.getMetadataId()).call(RevFeatureType.class).get();
            List<PropertyDescriptor> descriptors = revFeatureType.sortedDescriptors();
            ImmutableList<Optional<Object>> values = revFeature.getValues();
            SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(
                    (SimpleFeatureType) revFeatureType.type());
            String id = null;
            for (int i = 0; i < descriptors.size(); i++) {
                PropertyDescriptor descriptor = descriptors.get(i);
                if (descriptor.getName().getLocalPart().equals("id")) {
                    id = values.get(i).get().toString();
                }
                Optional<Object> value = values.get(i);
                featureBuilder.set(descriptor.getName(), value.orNull());
            }
            Preconditions.checkNotNull(id, "No 'id' attribute found");
            SimpleFeature feature = featureBuilder.buildFeature(id);
            unmapFeature(feature, flusher);


        }


        flusher.flushAll();


        // The above code will unmap all added or modified elements, but not deleted ones.
        // We now process the deletions, by comparing the current state of the mapped tree
        // with its state just after the mapping was created.


        if (entry.isPresent()) {
            Iterator<DiffEntry> diffs = command(DiffTree.class).setPathFilter(path)
                    .setNewTree(workingTree().getTree().getId())
                    .setOldTree(entry.get().getPostMappingId()).call();


            while (diffs.hasNext()) {
                DiffEntry diff = diffs.next();
                if (diff.changeType().equals(DiffEntry.ChangeType.REMOVED)) {


                    ObjectId featureId = diff.getOldObject().getNode().getObjectId();
                    RevFeature revFeature = command(RevObjectParse.class).setObjectId(featureId)
                            .call(RevFeature.class).get();
                    RevFeatureType revFeatureType = command(RevObjectParse.class)
                            .setObjectId(diff.getOldObject().getMetadataId())
                            .call(RevFeatureType.class).get();
                    List<PropertyDescriptor> descriptors = revFeatureType.sortedDescriptors();
                    ImmutableList<Optional<Object>> values = revFeature.getValues();
                    SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(
                            (SimpleFeatureType) revFeatureType.type());
                    String id = null;
                    for (int i = 0; i < descriptors.size(); i++) {
                        PropertyDescriptor descriptor = descriptors.get(i);
                        if (descriptor.getName().getLocalPart().equals("id")) {
                            id = values.get(i).get().toString();
                        }
                        Optional<Object> value = values.get(i);
                        featureBuilder.set(descriptor.getName(), value.orNull());
                    }
                    Preconditions.checkNotNull(id, "No 'id' attribute found");
                    SimpleFeature feature = featureBuilder.buildFeature(id);
                    Class<?> clazz = feature.getDefaultGeometryProperty().getType().getBinding();
                    String deletePath = clazz.equals(Point.class) ? OSMUtils.NODE_TYPE_NAME
                            : OSMUtils.WAY_TYPE_NAME;
                    workingTree().delete(deletePath, id);
                }

View Full Code Here

        Function<Feature, Optional<Feature>> function = new Function<Feature, Optional<Feature>>() {


            @Override
            @Nullable
            public Optional<Feature> apply(@Nullable Feature feature) {
                SimpleFeatureBuilder builder = new SimpleFeatureBuilder(featureType);
                for (Property property : feature.getProperties()) {
                    if (property instanceof GeometryAttribute) {
                        builder.set(featureType.getGeometryDescriptor().getName(),
                                property.getValue());
                    } else {
                        builder.set(property.getName(), property.getValue());
                    }
                }
                Feature modifiedFeature = builder.buildFeature(feature.getIdentifier().getID());
                return Optional.fromNullable(modifiedFeature);
            }


        };

View Full Code Here

    }


    private void unmapNode(SimpleFeature feature, FeatureMapFlusher mapFlusher) {
        boolean modified = false;
        String id = feature.getID();
        SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(OSMUtils.nodeType());
        Optional<RevFeature> rawFeature = command(RevObjectParse.class).setRefSpec(
                "WORK_HEAD:" + OSMUtils.NODE_TYPE_NAME + "/" + id).call(RevFeature.class);
        Map<String, String> tagsMap = Maps.newHashMap();
        long timestamp = System.currentTimeMillis();
        int version = 1;
        long changeset = -1;
        String user = UNKNOWN_USER;
        Collection<Tag> tags = Lists.newArrayList();
        if (rawFeature.isPresent()) {
            ImmutableList<Optional<Object>> values = rawFeature.get().getValues();
            tags = OSMUtils.buildTagsCollectionFromString(values.get(NODE_TAGS_FIELD_INDEX).get()
                    .toString());
            for (Tag tag : tags) {
                tagsMap.put(tag.getKey(), tag.getValue());
            }
            Optional<Object> timestampOpt = values.get(NODE_TIMESTAMP_FIELD_INDEX);
            if (timestampOpt.isPresent()) {
                timestamp = ((Long) timestampOpt.get()).longValue();
            }
            Optional<Object> versionOpt = values.get(NODE_VERSION_FIELD_INDEX);
            if (versionOpt.isPresent()) {
                version = ((Integer) versionOpt.get()).intValue();
            }
            Optional<Object> changesetOpt = values.get(NODE_CHANGESET_FIELD_INDEX);
            if (changesetOpt.isPresent()) {
                changeset = ((Long) changesetOpt.get()).longValue();
            }
            Optional<Object> userOpt = values.get(NODE_USER_FIELD_INDEX);
            if (userOpt.isPresent()) {
                user = (String) userOpt.get();
            }
        }


        Map<String, String> unaliased = Maps.newHashMap();
        Collection<Property> properties = feature.getProperties();
        for (Property property : properties) {
            String name = property.getName().getLocalPart();
            if (name.equals("id")
                    || Geometry.class.isAssignableFrom(property.getDescriptor().getType()
                            .getBinding())) {
                continue;
            }
            Object value = property.getValue();
            if (value != null) {
                String tagName = name;
                if (mapping != null) {
                    if (unaliased.containsKey(name)) {
                        tagName = unaliased.get(name);
                    } else {
                        tagName = mapping.getTagNameFromAlias(path, tagName);
                        unaliased.put(name, tagName);
                    }
                }


                if (!DefaultField.isDefaultField(tagName)) {
                    if (tagsMap.containsKey(tagName)) {
                        if (!modified) {
                            String oldValue = tagsMap.get(tagName);
                            modified = !value.equals(oldValue);
                        }
                    } else {
                        modified = true;
                    }
                    tagsMap.put(tagName, value.toString());
                }
            }
        }


        if (!modified && rawFeature.isPresent()) {
            // no changes after unmapping tags, so there's nothing else to do
            return;
        }


        Collection<Tag> newTags = Lists.newArrayList();
        Set<Entry<String, String>> entries = tagsMap.entrySet();
        for (Entry<String, String> entry : entries) {
            newTags.add(new Tag(entry.getKey(), entry.getValue()));
        }
        featureBuilder.set("tags", OSMUtils.buildTagsString(newTags));
        featureBuilder.set("location", feature.getDefaultGeometry());
        featureBuilder.set("changeset", changeset);
        featureBuilder.set("timestamp", timestamp);
        featureBuilder.set("version", version);
        featureBuilder.set("user", user);
        featureBuilder.set("visible", true);
        if (rawFeature.isPresent()) {
            // the feature has changed, so we cannot reuse some attributes.
            // We reconstruct the feature and insert it
            featureBuilder.set("timestamp", System.currentTimeMillis());
            featureBuilder.set("changeset", null);
            featureBuilder.set("version", null);
            featureBuilder.set("visible", true);
            mapFlusher.put("node", featureBuilder.buildFeature(id));
        } else {
            // The feature didn't exist, so we have to add it
            mapFlusher.put("node", featureBuilder.buildFeature(id));
        }


    }

View Full Code Here

     * @param coord
     * @return the id of the created node
     */
    private Long createNodeForCoord(Coordinate coord, FeatureMapFlusher flusher) {
        long id = -1 * System.currentTimeMillis(); // TODO: This has to be changed!!!
        SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(OSMUtils.nodeType());
        featureBuilder.set("tags", null);
        featureBuilder.set("location", gf.createPoint(coord));
        featureBuilder.set("changeset", null);
        featureBuilder.set("timestamp", System.currentTimeMillis());
        featureBuilder.set("version", 1);
        featureBuilder.set("user", null);
        featureBuilder.set("visible", true);
        flusher.put("node", featureBuilder.buildFeature(Long.toString(id)));
        return id;
    }

View Full Code Here

    }


    private void unmapWay(SimpleFeature feature, FeatureMapFlusher flusher) {
        boolean modified = false;
        String id = feature.getID();
        SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(OSMUtils.wayType());
        Optional<RevFeature> rawFeature = command(RevObjectParse.class).setRefSpec(
                "WORK_HEAD:" + OSMUtils.WAY_TYPE_NAME + "/" + id).call(RevFeature.class);
        Map<String, String> tagsMap = Maps.newHashMap();
        long timestamp = System.currentTimeMillis();
        int version = 1;
        long changeset = -1;
        String user = UNKNOWN_USER;
        Collection<Tag> tags = Lists.newArrayList();
        if (rawFeature.isPresent()) {
            ImmutableList<Optional<Object>> values = rawFeature.get().getValues();
            tags = OSMUtils.buildTagsCollectionFromString(values.get(WAY_TAGS_FIELD_INDEX).get()
                    .toString());
            for (Tag tag : tags) {
                tagsMap.put(tag.getKey(), tag.getValue());
            }
            Optional<Object> timestampOpt = values.get(WAY_TIMESTAMP_FIELD_INDEX);
            if (timestampOpt.isPresent()) {
                timestamp = ((Long) timestampOpt.get()).longValue();
            }
            Optional<Object> versionOpt = values.get(WAY_VERSION_FIELD_INDEX);
            if (versionOpt.isPresent()) {
                version = ((Integer) versionOpt.get()).intValue();
            }
            Optional<Object> changesetOpt = values.get(WAY_CHANGESET_FIELD_INDEX);
            if (changesetOpt.isPresent()) {
                changeset = ((Long) changesetOpt.get()).longValue();
            }
            Optional<Object> userOpt = values.get(WAY_USER_FIELD_INDEX);
            if (userOpt.isPresent()) {
                user = (String) userOpt.get();
            }
        }


        Map<String, String> unaliased = Maps.newHashMap();
        Collection<Property> properties = feature.getProperties();
        for (Property property : properties) {
            String name = property.getName().getLocalPart();
            if (name.equals("id")
                    || name.equals("nodes")
                    || Geometry.class.isAssignableFrom(property.getDescriptor().getType()
                            .getBinding())) {
                continue;
            }
            Object value = property.getValue();
            if (value != null) {
                String tagName = name;
                if (mapping != null) {
                    if (unaliased.containsKey(name)) {
                        tagName = unaliased.get(name);
                    } else {
                        tagName = mapping.getTagNameFromAlias(path, tagName);
                        unaliased.put(name, tagName);
                    }
                }


                if (!DefaultField.isDefaultField(tagName)) {
                    if (tagsMap.containsKey(tagName)) {
                        if (!modified) {
                            String oldValue = tagsMap.get(tagName);
                            modified = !value.equals(oldValue);
                        }
                    } else {
                        modified = true;
                    }
                    tagsMap.put(tagName, value.toString());
                }
            }
        }


        if (!modified && rawFeature.isPresent()) {
            // no changes after unmapping tags, so there's nothing else to do
            return;
        }


        tags.clear();
        Set<Entry<String, String>> entries = tagsMap.entrySet();
        for (Entry<String, String> entry : entries) {
            tags.add(new Tag(entry.getKey(), entry.getValue()));
        }


        Geometry geom = (Geometry) feature.getDefaultGeometry();
        LineString line;
        if (geom instanceof LineString) {
            line = (LineString) geom;
        } else {
            line = gf.createLineString(geom.getCoordinates());
        }
        featureBuilder.set("visible", true);
        featureBuilder.set("tags", OSMUtils.buildTagsString(tags));
        featureBuilder.set("way", line);
        featureBuilder.set("changeset", changeset);
        featureBuilder.set("timestamp", timestamp);
        featureBuilder.set("version", version);
        featureBuilder.set("user", user);
        featureBuilder.set("nodes", getNodeStringFromWay(feature, flusher));
        if (rawFeature.isPresent()) {
            // the feature has changed, so we cannot reuse some attributes
            featureBuilder.set("timestamp", System.currentTimeMillis());
            featureBuilder.set("changeset", -changeset); // temporary negative changeset ID
            // featureBuilder.set("version", version);
            flusher.put("way", featureBuilder.buildFeature(id));
        } else {
            flusher.put("way", featureBuilder.buildFeature(id));
        }


    }

View Full Code Here

        private int numInserts;


        public InsertTask(GeoGigDataStore store, int numInserts) {
            this.dataStore = store;
            this.numInserts = numInserts;
            this.builder = new SimpleFeatureBuilder(pointType);
        }

View Full Code Here

    private static final RevFeatureType NODE_REV_TYPE = RevFeatureTypeImpl.build(nodeType());


    private static SimpleFeature toFeature(Primitive feature, Geometry geom) {


        SimpleFeatureType ft = feature instanceof Node ? nodeType() : wayType();
        SimpleFeatureBuilder builder = new SimpleFeatureBuilder(ft);


        // "visible:Boolean,version:Int,timestamp:long,[location:Point | way:LineString];
        builder.set("visible", Boolean.valueOf(feature.isVisible()));
        builder.set("version", Integer.valueOf(feature.getVersion()));
        builder.set("timestamp", Long.valueOf(feature.getTimestamp()));
        builder.set("changeset", Long.valueOf(feature.getChangesetId()));


        String tags = buildTagsString(feature.getTags());
        builder.set("tags", tags);


        String user = feature.getUserName() + ":" + feature.getUserId();
        builder.set("user", user);


        if (feature instanceof Node) {
            builder.set("location", geom);
        } else if (feature instanceof Way) {
            builder.set("way", geom);
            String nodes = buildNodesString(((Way) feature).getNodes());
            builder.set("nodes", nodes);
        } else {
            throw new IllegalArgumentException();
        }


        String fid = String.valueOf(feature.getId());
        SimpleFeature simpleFeature = builder.buildFeature(fid);
        return simpleFeature;
    }

View Full Code Here

        Function<Feature, Optional<Feature>> function = new Function<Feature, Optional<Feature>>() {


            @Override
            @Nullable
            public Optional<Feature> apply(@Nullable Feature feature) {
                SimpleFeatureBuilder builder = new SimpleFeatureBuilder(featureType);
                for (Property property : feature.getProperties()) {
                    if (property instanceof GeometryAttribute) {
                        builder.set(featureType.getGeometryDescriptor().getName(),
                                property.getValue());
                    } else {
                        builder.set(property.getName(), property.getValue());
                    }
                }
                Feature modifiedFeature = builder.buildFeature(feature.getIdentifier().getID());
                return Optional.fromNullable(modifiedFeature);
            }


        };

View Full Code Here

                if (ref.path().startsWith(OSMUtils.NODE_TYPE_NAME)) {
                    featureType = OSMUtils.nodeType();
                } else {
                    featureType = OSMUtils.wayType();
                }
                SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(featureType);
                RevFeatureType revFeatureType = RevFeatureTypeImpl.build(featureType);
                List<PropertyDescriptor> descriptors = revFeatureType.sortedDescriptors();
                ImmutableList<Optional<Object>> values = revFeature.getValues();
                for (int i = 0; i < descriptors.size(); i++) {
                    PropertyDescriptor descriptor = descriptors.get(i);
                    Optional<Object> value = values.get(i);
                    featureBuilder.set(descriptor.getName(), value.orNull());
                }
                SimpleFeature feature = featureBuilder.buildFeature(ref.name());
                Entity entity = converter.toEntity(feature, null);
                EntityContainer container;
                if (entity instanceof Node) {
                    container = new NodeContainer((Node) entity);
                } else {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.geotools.feature.simple.SimpleFeatureBuilder

business.CalculateRoutes

com.gi.engine.arcgis.EsriJsonUtil

com.moesol.geoserver.sync.samples.Samples

MainView

org.catais.veriso.interlis.IliReader

org.geoserver.feature.retype.FullyRetypingDataStoreTest

org.geoserver.feature.retype.RetypingDataStoreTest

org.geoserver.feature.RetypingFeatureCollection$RetypingFeatureReader

org.geoserver.feature.RetypingFeatureCollection$RetypingFeatureWriter

org.geoserver.feature.RetypingFeatureCollection$RetypingIterator

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.