public RevFeatureBuilder addAll(@NonNull List<Object> values) { for (Object v : values) { addValue(v); } return this; }
public RevFeatureBuilder addAll(@NonNull Object... values) { for (Object v : values) { addValue(v); } return this; }
public RevFeatureBuilder addProperty(@NonNull Property featureProp) { // This is where we might handle complex properties if ever supported addValue(featureProp.getValue()); return this; }
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; }
@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(); }
/** * 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(); } }
private List<FeatureInfo> createFeatures(NodeRef layer, int featureCount) { List<FeatureInfo> features = new ArrayList<>(); ObjectId featureTypeId = layer.getDefaultMetadataId(); for (int i = 0; i < featureCount; i++) { String fid = String.valueOf(i); RevFeature feature = RevFeature.builder().addValue(fid).addValue(i).addValue(null) .build(); String path = NodeRef.appendChild(layer.path(), fid); FeatureInfo featureInfo = FeatureInfo.insert(feature, featureTypeId, path); features.add(featureInfo); } return features; }
@Test public void tesFeaturePropertyOfUnsupportedType() { TestSerializableObject serializableObject = new TestSerializableObject(); serializableObject.words = "words to serialize"; try { RevFeature.builder().addValue(1).addValue("s").addValue(serializableObject).build(); fail("Expected IAE"); } catch (IllegalArgumentException iae) { String expected = String.format( "Objects of type %s are not supported as property values (%s)", serializableObject.getClass().getName(), serializableObject); assertEquals(expected, iae.getMessage()); } }
mergedValues.addValue(merged);
public @Before void before() { mockSharedCache = mock(SharedCache.class); cacheId1 = new CacheIdentifier(0); cacheId2 = new CacheIdentifier(1000); cache1 = new ObjectCache(() -> mockSharedCache, cacheId1); cache2 = new ObjectCache(() -> mockSharedCache, cacheId2); o1 = RevFeature.builder().addValue(0L).addValue("zero").build(); o2 = RevFeature.builder().addValue(1L).addValue("one").build(); k11 = cacheId1.create(o1.getId()); k21 = cacheId2.create(o1.getId()); k22 = cacheId2.create(o2.getId()); }
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()); } }
@Test public void testBuildWithAddValue() throws Exception { SimpleFeature f = (SimpleFeature) points1; RevFeature feature = RevFeature.builder().build(f); RevFeatureBuilder b = RevFeature.builder(); for (int i = 0; i < f.getAttributeCount(); i++) { b.addValue(f.getAttribute(i)); } RevFeature built = b.build(); assertEquals(feature, built); for (int i = 0; i < f.getAttributeCount(); i++) { assertEquals(f.getAttribute(i), built.getValues().get(i).orNull()); } }
@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)); }