@Override public void write() throws IOException { Preconditions.checkState(last != null, "next() hasn't been called"); String parentTreePath = typePath; RevFeature feature = RevFeature.builder().build(last); String path = NodeRef.appendChild(parentTreePath, last.getID()); FeatureInfo fi = FeatureInfo.insert(feature, featureTypeId, path); workingTree.insert(fi); }
public static RevFeature readFeature(ObjectId id, DataInput in) throws IOException { final int count = in.readInt(); final RevFeatureBuilder builder = RevFeature.builder(); for (int i = 0; i < count; i++) { final byte fieldTag = in.readByte(); final FieldType fieldType = FieldType.valueOf(fieldTag); Object value = DataStreamValueSerializerV1.INSTANCE.decode(fieldType, in); builder.addValue(value); } RevFeature built = builder.build(); return built; }
public RevFeature readFeature(@Nullable ObjectId id, DataInput in) throws IOException { final int count = readUnsignedVarInt(in); final RevFeatureBuilder builder = RevFeature.builder(); for (int i = 0; i < count; i++) { final byte fieldTag = in.readByte(); final FieldType fieldType = FieldType.valueOf(fieldTag); Object value = valueEncoder.decode(fieldType, in); builder.addValueNoCopy(value); } RevFeature built = builder.id(id).build(); return built; }
@Override protected RevFeature read(ObjectId id, BufferedReader reader, TYPE type) throws IOException { Preconditions.checkArgument(TYPE.FEATURE.equals(type), "Wrong type: %s", type.name()); RevFeatureBuilder builder = RevFeature.builder(); String line; while ((line = reader.readLine()) != null) { builder.addValue(parseAttribute(line)); } return builder.id(id).build(); }
@Test public void testEnforcesPolygonNormalization() throws Exception { // outer ring in cw order, inner rings in ccw order String normalizedWKT = "POLYGON((0 0, 0 9, 9 9, 9 0, 0 0), (3 3, 6 3, 6 6, 3 6, 3 3))"; // outer ring in ccw order, inner rings in cc order String reversedWKT = "POLYGON((0 0, 9 0, 9 9, 0 9, 0 0), (3 3, 3 6, 6 6, 6 3, 3 3))"; Geometry normalized = new WKTReader().read(normalizedWKT); Geometry reversed = new WKTReader().read(reversedWKT); assertTrue(normalized.equalsExact(normalized.norm())); assertFalse(reversed.equalsExact(reversed.norm())); RevFeatureBuilder builder = RevFeature.builder(); RevFeature norm = builder.addValue(normalized).build(); RevFeature rev = builder.reset().addValue(reversed).build(); Geometry expected = (Geometry) norm.getValues().get(0).get(); Geometry actual = (Geometry) rev.getValues().get(0).get(); assertTrue(normalized.equalsExact(expected)); assertTrue(normalized.equalsExact(actual)); }
public static RevFeature createPointFeature(double x, double y, Object... extraAttribues) { RevFeatureBuilder builder = RevFeature.builder(); builder.addValue(gf.createPoint(new Coordinate(x, y))); if (extraAttribues != null) { builder.addAll(Lists.newArrayList(extraAttribues)); } RevFeature feature = builder.build(); return feature; }
@Test public void testReset() { SimpleFeature f = (SimpleFeature) points1; RevFeature feature = RevFeature.builder().build(f); RevFeatureBuilder b = RevFeature.builder(); b.addValue(1000); b.addValue("str"); b.reset(); for (Property p : f.getProperties()) { b.addProperty(p); } RevFeature built = b.build(); assertEquals(feature, built); for (int i = 0; i < f.getAttributeCount(); i++) { assertEquals(f.getAttribute(i), built.getValues().get(i).orNull()); } }
/** * Only for testing: allows to return a {@link RevFeature} with the specified id instead of the * one resulting from {@link HashObject} */ public static RevFeature featureForceId(ObjectId forceId, Object... rawValues) { RevFeature revFeature = RevFeature.builder().addAll(rawValues).id(forceId).build(); return revFeature; }
@Test public void testAddAll() { SimpleFeature f = (SimpleFeature) points1; RevFeature feature = RevFeature.builder().build(f); RevFeatureBuilder b = RevFeature.builder(); b.addAll(f.getAttributes()); RevFeature builtWithList = b.build(); assertEquals(feature, builtWithList); b.reset(); b.addAll(f.getAttributes().toArray(new Object[f.getAttributeCount()])); RevFeature builtWithArray = b.build(); assertEquals(feature, builtWithArray); for (int i = 0; i < f.getAttributeCount(); i++) { assertEquals(f.getAttribute(i), builtWithList.getValues().get(i).orNull()); } }
@Test public void testBuildWithAddProperty() throws Exception { SimpleFeature f = (SimpleFeature) points1; RevFeature feature = RevFeature.builder().build(f); RevFeatureBuilder b = RevFeature.builder(); for (Property p : f.getProperties()) { b.addProperty(p); } RevFeature built = b.build(); assertEquals(feature, built); for (int i = 0; i < f.getAttributeCount(); i++) { assertEquals(f.getAttribute(i), built.getValues().get(i).orNull()); } }
public RevFeatureBuilder addAll(@NonNull List<Object> values) { for (Object v : values) { addValue(v); } return this; }
/** * Adds the provided value to the tail of the sequence of attribute values that compose the * {@link RevFeature} being built. */ public RevFeatureBuilder addValue(@Nullable Object value) { return addValueNoCopy(value); }
public RevFeatureBuilder addAll(@NonNull Object... values) { for (Object v : values) { addValue(v); } return this; }
@Override public RevFeature apply(ResultSet rs) { builder.reset(); try { for (String attName : attNames) { Object value = rs.getObject(attName); if (attName.equals(geometryAttribute) && value != null) { byte[] bytes = (byte[]) value; value = new GeoPkgGeomReader(bytes).get(); } builder.set(attName, value); } SimpleFeature feature = builder.buildFeature("fakeId"); return RevFeature.builder().build(feature); } catch (SQLException | IOException e) { throw new RuntimeException(e); } } }
/** * Constructs a new {@link RevFeature} from the provided {@link Feature}. * * @param feature the feature to build from * @return the newly constructed RevFeature */ public RevFeature build(@NonNull Feature feature) { if (feature instanceof SimpleFeature) { // Just SimpleFeature sf = (SimpleFeature) feature; int attributeCount = sf.getAttributeCount(); for (int i = 0; i < attributeCount; i++) { addValue(sf.getAttribute(i)); } } else { Collection<Property> props = feature.getProperties(); props.forEach(this::addProperty); } return build(); } }
@Test public void testRevFeatureToString() { List<Object> values = Lists.newArrayList("StringProp1_1", new Integer(1000), "POINT(1 1)"); RevFeature feature = RevFeature.builder().addAll(values).build(); String featureString = feature.toString(); String expected = RevObjects.toString(feature); assertEquals(expected, featureString); } }
public RevFeatureBuilder addProperty(@NonNull Property featureProp) { // This is where we might handle complex properties if ever supported addValue(featureProp.getValue()); return this; }
@Override public FeatureInfo apply(SimpleFeature f) { return FeatureInfo.insert(RevFeature.builder().build(f), featureTypeId, NodeRef.appendChild(treePath, f.getID())); }};