@Override protected void setUpInternal() throws Exception { featureType = RevFeatureTypeBuilder.build(pointsType); }
public RevFeatureType readFeatureType(@Nullable ObjectId id, DataInput in, FeatureTypeFactory typeFactory) throws IOException { Name name = readName(in); int propertyCount = readUnsignedVarInt(in); List<AttributeDescriptor> attributes = new ArrayList<AttributeDescriptor>(); for (int i = 0; i < propertyCount; i++) { attributes.add(readAttributeDescriptor(in, typeFactory)); } SimpleFeatureType ftype = typeFactory.createSimpleFeatureType(name, attributes, null, false, Collections.<Filter> emptyList(), BasicFeatureTypes.FEATURE, null); RevFeatureType revtype; if (id == null) { revtype = RevFeatureTypeBuilder.build(ftype); } else { revtype = RevFeatureTypeBuilder.create(id, ftype); } return revtype; }
/** * Builds a {@link RevFeatureType} for the given feature type, computing its id throuh * {@link HashObject} */ public static RevFeatureType build(FeatureType featureType) { checkNotNull(featureType); featureType = adapt(featureType); ObjectId id = HashObject.hashFeatureType(featureType); return RevFeatureTypeBuilder.create(id, featureType); }
public static RevFeatureType readFeatureType(ObjectId id, DataInput in, FeatureTypeFactory typeFactory) throws IOException { Name name = readName(in); int propertyCount = in.readInt(); List<AttributeDescriptor> attributes = new ArrayList<AttributeDescriptor>(); for (int i = 0; i < propertyCount; i++) { attributes.add(readAttributeDescriptor(in, typeFactory)); } SimpleFeatureType ftype = typeFactory.createSimpleFeatureType(name, attributes, null, false, Collections.<Filter> emptyList(), BasicFeatureTypes.FEATURE, null); return RevFeatureTypeBuilder.create(id, ftype); }
@Test public void testGet() throws Exception { ObjectId meta1 = getOID(1); ObjectId meta2 = getOID(2); SimpleFeatureType fType1 = DataUtilities.createType("location", "the_geom:Point:srid=4326,name:String,name2:String"); RevFeatureType revft1 = RevFeatureTypeBuilder.create(getOID(1), fType1); SimpleFeatureType fType2 = DataUtilities.createType("location", "the_geom:Point:srid=4326,name3:String,name4:String"); RevFeatureType revft2 = RevFeatureTypeBuilder.create(getOID(1), fType2); ObjectDatabase odb = mock(ObjectDatabase.class); when(odb.getFeatureType(meta1)).thenReturn(revft1); when(odb.getFeatureType(meta2)).thenReturn(revft2); MultiFeatureTypeBuilder builder = new MultiFeatureTypeBuilder(odb); FeatureBuilder fb1 = builder.get(meta1); FeatureBuilder fb2 = builder.get(meta2); Assert.isTrue(fb1 == builder.get(meta1)); // not rebuilt Assert.isTrue(fb2 == builder.get(meta2)); // not rebuilt Assert.isTrue(fb1.getType().equals(revft1)); Assert.isTrue(fb2.getType().equals(revft2)); }
RevFeatureType rft = types.get(ft); if (rft == null) { rft = RevFeatureTypeBuilder.build(ft); types.put(ft, rft); repository.objectDatabase().put(rft);
RevFeatureType revft1 = RevFeatureTypeBuilder.create(meta1, fType1);
RevFeatureType rft = types.get(ft); if (rft == null) { rft = RevFeatureTypeBuilder.build(ft); types.put(ft, rft); repository.objectDatabase().put(rft);
@Test public void testBuild() throws Exception { ObjectId meta1 = getOID(1); SimpleFeatureType fType1 = DataUtilities.createType("location", "the_geom:Point:srid=4326,name:String,name2:String"); RevFeatureType revft1 = RevFeatureTypeBuilder.create(getOID(1), fType1); ObjectDatabase odb = mock(ObjectDatabase.class); when(odb.getFeatureType(meta1)).thenReturn(revft1); WKTReader2 wkt = new WKTReader2(); RevFeature feat = RevObjectTestSupport.feature(wkt.read("POINT(0 0)"), "abc", "def"); Node n1 = Node.create("name1", getOID(2), meta1, TYPE.FEATURE, new Envelope()); NodeRef nr1 = new NodeRef(n1, "testcase", meta1); ObjectInfo<RevFeature> fi = ObjectInfo.of(nr1, feat); MultiFeatureTypeBuilder builder = new MultiFeatureTypeBuilder(odb); SimpleFeature sf = builder.apply(fi); Assert.isTrue(sf.getAttribute("name").equals("abc")); Assert.isTrue(sf.getAttribute("name2").equals("def")); }
private Iterator<Feature> transformFeatures(SimpleFeatureType featureType, String path) { String refspec = Ref.WORK_HEAD + ":" + path; Iterator<NodeRef> oldFeatures = command(LsTreeOp.class).setReference(refspec) .setStrategy(Strategy.FEATURES_ONLY).call(); RevFeatureType revFeatureType = RevFeatureTypeBuilder.build(featureType); Iterator<Feature> transformedIterator = transformIterator(oldFeatures, revFeatureType); return transformedIterator; }
RevFeatureType fakeType = RevFeatureTypeBuilder.create(metadataId, pointsType); if (!db.exists(fakeType.getId())) { db.put(fakeType);
return RevFeatureTypeBuilder.build(featureType);
@Override protected RevFeatureType read(ObjectId id, BufferedReader reader, TYPE type) throws IOException { Preconditions.checkArgument(TYPE.FEATURETYPE.equals(type), "Wrong type: %s", type.name()); builder = new SimpleFeatureTypeBuilder(); typeFactory = builder.getFeatureTypeFactory(); String name = parseLine(requireLine(reader), "name"); SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); if (name.contains(":")) { int idx = name.lastIndexOf(':'); String namespace = name.substring(0, idx); String local = name.substring(idx + 1); builder.setName(new NameImpl(namespace, local)); } else { builder.setName(new NameImpl(name)); } String line; while ((line = reader.readLine()) != null) { builder.add(parseAttributeDescriptor(line)); } SimpleFeatureType sft = builder.buildFeatureType(); return RevFeatureTypeBuilder.build(sft); }
@Override protected void setUpInternal() throws Exception { insertAndAdd(points1, points2, points3); commit("inital"); SimpleFeatureType fullSchema = pointsType; RevFeatureType nativeType = RevFeatureTypeBuilder.build(fullSchema); Context actualContext = repo.context(); context = spy(actualContext); difftree = spy(context.command(DiffTree.class)); doReturn(difftree).when(context).command(eq(DiffTree.class)); NodeRef typeRef = context.workingTree().getFeatureTypeTrees().get(0); FeatureReaderBuilder b = FeatureReaderBuilder.builder(context, nativeType, typeRef); builder = spy(b); }
@Test public void testToString() { RevFeatureType featureType = RevFeatureTypeBuilder.build(linesType); String featureTypeString = featureType.toString(); assertEquals("FeatureType[" + featureType.getId().toString() + "; " + "sp: String, ip: Integer, pp: LineString]", featureTypeString); } }
protected void insert(Repository repo, Iterable<? extends Feature> features) throws Exception { WorkingTree workingTree = repo.workingTree(); FeatureType type = features.iterator().next().getType(); repo.objectDatabase().put(RevFeatureTypeBuilder.build(type)); final String treePath = type.getName().getLocalPart(); Iterable<FeatureInfo> featureInfos = Iterables.transform(features, (f) -> featureInfo(treePath, f)); workingTree.insert(featureInfos.iterator(), new DefaultProgressListener()); }
private Node createFeatureNode(final ObjectId id, final String name, @Nullable final BoundingBox bounds, final FeatureType type) { Envelope bbox; if (bounds == null) { bbox = null; } else if (bounds instanceof Envelope) { bbox = (Envelope) bounds; } else { bbox = new Envelope(bounds.getMinimum(0), bounds.getMaximum(0), bounds.getMinimum(1), bounds.getMaximum(1)); } RevFeatureType revFeatureType = revFeatureTypes.get(type.getName().getLocalPart()); if (null == revFeatureType) { revFeatureType = RevFeatureTypeBuilder.build(type); revFeatureTypes.put(type.getName().getLocalPart(), revFeatureType); } ObjectId defaultMetadataId = revFeatureType.getId(); ObjectId metadataId = revFeatureType.getId().equals(defaultMetadataId) ? ObjectId.NULL : revFeatureType.getId(); Node node = Node.create(name, id, metadataId, TYPE.FEATURE, bbox); return node; }
@Test public void testAddFeatureAttributePatch() throws Exception { Patch patch = new Patch(); String path = NodeRef.appendChild(pointsName, points1.getIdentifier().getID()); Map<PropertyDescriptor, AttributeDiff> map = Maps.newHashMap(); Object newValue = points1B.getProperty("extra").getValue(); GenericAttributeDiffImpl diff = new GenericAttributeDiffImpl(null, newValue); map.put(modifiedPointsType.getDescriptor("extra"), diff); FeatureDiff featureDiff = new FeatureDiff(path, map, RevFeatureTypeBuilder.build(pointsType), RevFeatureTypeBuilder.build(modifiedPointsType)); patch.addModifiedFeature(featureDiff); patch.addFeatureType(RevFeatureTypeBuilder.build(modifiedPointsType)); testPatch(patch); }
@Test public void testRemoveFeatureAttributePatch() throws Exception { Patch patch = new Patch(); String path = NodeRef.appendChild(pointsName, points1.getIdentifier().getID()); Map<PropertyDescriptor, AttributeDiff> map = Maps.newHashMap(); Object oldValue = points1B.getProperty("extra").getValue(); GenericAttributeDiffImpl diff = new GenericAttributeDiffImpl(oldValue, null); map.put(modifiedPointsType.getDescriptor("extra"), diff); FeatureDiff featureDiff = new FeatureDiff(path, map, RevFeatureTypeBuilder.build(modifiedPointsType), RevFeatureTypeBuilder.build(pointsType)); patch.addModifiedFeature(featureDiff); patch.addFeatureType(RevFeatureTypeBuilder.build(pointsType)); testPatch(patch); }
final RevFeatureType revFeatureType = RevFeatureTypeBuilder.build(featureType); final SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(featureType);