/** * @deprecated use {@link RevObjectFactory#createNode} */ public static Node create(final @NonNull String name, final @NonNull ObjectId oid, final @NonNull ObjectId metadataId, final @NonNull TYPE type, @Nullable Envelope bounds, @Nullable Map<String, Object> extraData) { return RevObjectFactory.defaultInstance().createNode(name, oid, metadataId, type, bounds, extraData); } }
public RevTag build(@Nullable ObjectId id, @NonNull String name, @NonNull ObjectId commitId, @NonNull String message, @NonNull RevPerson tagger) { if (id == null) { id = HashObjectFunnels.hashTag(name, commitId, message, tagger); } if (factory == null) { factory = RevObjectFactory.defaultInstance(); } return factory.createTag(id, name, commitId, message, tagger); } }
/** * Creates and returns a new {@link RevFeatureType} for the given FeatureType with the given * {@link ObjectId id} without verifying the SHA-1 matches the contents of the * {@link RevFeatureType} */ public RevFeatureType build(@Nullable ObjectId id, @NonNull FeatureType ftype) { FeatureType featureType = adapt(ftype); ObjectId oid = id == null ? HashObjectFunnels.hashFeatureType(featureType) : id; return RevObjectFactory.defaultInstance().createFeatureType(oid, featureType); }
private Node treeNode(String name, ObjectId treeId, ObjectId metadataId) { Node node = RevObjectFactory.defaultInstance().createNode(name, treeId, metadataId, TYPE.TREE, null, null); return node; }
public Node update(final ObjectId newId, final @Nullable Envelope newBounds) { ObjectId mdId = getMetadataId().or(ObjectId.NULL); return RevObjectFactory.defaultInstance().createNode(getName(), newId, mdId, getType(), newBounds, getExtraData()); }
public static final Bucket readBucket(int index, DataInput in) throws IOException { ObjectId objectId = ObjectId.readFrom(in); Envelope bounds = readBBox(in); return RevObjectFactory.defaultInstance().createBucket(objectId, index, bounds); }
private Node feature(int i, ObjectId oid) { String name = String.valueOf(i); TYPE type = TYPE.FEATURE; Envelope bounds = new Envelope(i, i, i, i); return RevObjectFactory.defaultInstance().createNode(name, oid, metadataId, type, bounds, null); } }
@Override public DiffEntry apply(String featurePath) { Node node = RevObjectFactory.defaultInstance().createNode( NodeRef.nodeFromPath(featurePath), ObjectId.NULL, ObjectId.NULL, TYPE.FEATURE, null, null); String parentPath = NodeRef.parentPath(featurePath); NodeRef oldFeature = new NodeRef(node, parentPath, ObjectId.NULL); return new DiffEntry(oldFeature, null); }};
@Test public void testBucketsTree() throws IOException { RevTree tree; SortedSet<Bucket> buckets = new TreeSet<>(); for (int i = 0; i < 32; i++) { buckets.add(RevObjectFactory.defaultInstance().createBucket(hashString("b" + i), i, new Envelope(-i, -i, i, i))); } tree = tree(1024, null, null, buckets); encodeDecode(tree); }
@Test public void testNaturalOrder() { assertEquals(0, RevTree.EMPTY.compareTo(RevTree.EMPTY)); ObjectId oId1 = ObjectId.valueOf("abc123000000000000001234567890abcdef0001"); ObjectId oId2 = ObjectId.valueOf("abc123000000000000001234567890abcdef0002"); RevFeature f1 = RevObjectFactory.defaultInstance().createFeature(oId1, Collections.singletonList("1")); RevFeature f2 = RevObjectFactory.defaultInstance().createFeature(oId2, Collections.singletonList("2")); assertTrue(f1.compareTo(f2) < 0); assertTrue(f2.compareTo(f1) > 0); }
private RevTree createTree(int numChildren) { RevTreeBuilder rtb = RevTreeBuilder.builder(odb); for (int i = 0; i < numChildren; i++) { String key = FEATURE_PREFIX + i; Node ref = RevObjectFactory.defaultInstance().createNode(key, FAKE_ID, FAKE_ID, TYPE.FEATURE, null, null); rtb.put(ref); } return rtb.build(); }
/** * Creates a root node for the given tree as the one {@link PostOrderDiffWalk} should use to * start the traversal */ private static NodeRef nodeFor(RevTree root) { Envelope bounds = SpatialOps.boundsOf(root); return NodeRef.createRoot(RevObjectFactory.defaultInstance().createNode(NodeRef.ROOT, root.getId(), ObjectId.NULL, TYPE.TREE, bounds, null)); }
@Test public void testHashCode() { Node node = RevObjectFactory.defaultInstance().createNode("Points.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURE, null, null); Node node2 = RevObjectFactory.defaultInstance().createNode("Lines.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0001"), ObjectId.NULL, TYPE.FEATURE, null, null); assertNotSame(node.hashCode(), node2.hashCode()); }
@Test public void testLazyNodeGetExtaData() throws IOException { final Map<String, Object> expected = extraData(0); final Node originalNode = RevObjectFactory.defaultInstance().createNode("feature-0", RevObjectTestSupport.hashString("1"), ObjectId.NULL, TYPE.FEATURE, null, expected); NodeSet nodeset = encodedDecode(Collections.singletonList(originalNode), TYPE.FEATURE); Node lazyNode = nodeset.build().get(0); Map<String, Object> extraData = lazyNode.getExtraData(); assertEquals(expected, extraData); }
@Test public void testCompareTo() { Node node = RevObjectFactory.defaultInstance().createNode("Points.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURE, null, null); Node node2 = RevObjectFactory.defaultInstance().createNode("Lines.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0001"), ObjectId.NULL, TYPE.FEATURE, null, null); assertTrue(node.compareTo(node2) > 0); assertTrue(node2.compareTo(node) < 0); assertTrue(node.compareTo(node) == 0); }
private RevTree createRoot(ObjectDatabase db, final RevTree tree1, final RevTree tree2) { RevTreeBuilder rootBuilder = RevTreeBuilder.builder(db); rootBuilder.put(RevObjectFactory.defaultInstance().createNode("tree1", tree1.getId(), metadataId, TYPE.TREE, SpatialOps.boundsOf(tree1), null)); rootBuilder.put(RevObjectFactory.defaultInstance().createNode("tree2", tree2.getId(), metadataId, TYPE.TREE, SpatialOps.boundsOf(tree2), null)); RevTree root = rootBuilder.build(); db.put(root); return root; }
@Test public void testNodeAndNodeRefToString() { Node node = RevObjectFactory.defaultInstance().createNode("Points.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURE, null, null); NodeRef nodeRef = new NodeRef(node, "Points", ObjectId.NULL); String readableNode = nodeRef.toString(); assertTrue(readableNode .equals("NodeRef[Points/Points.1 -> " + node.getObjectId().toString() + "]")); }
public RevTreeBuilder createTreesTreeBuilder(ObjectStore source, int numSubTrees, int featuresPerSubtre, ObjectId metadataId) { RevTreeBuilder builder = RevTreeBuilder.builder(source); for (int treeN = 0; treeN < numSubTrees; treeN++) { RevTree subtree = createFeaturesTreeBuilder(source, "subtree" + treeN, featuresPerSubtre).build(); source.put(subtree); builder.put(RevObjectFactory.defaultInstance().createNode("subtree" + treeN, subtree.getId(), metadataId, TYPE.TREE, null, null)); } return builder; }
@Test public void testRoundTripBucketsFull() throws IOException { ObjectId id = RevObjectTestSupport.hashString("fake"); long size = 100000000; int childTreeCount = 0; SortedSet<Bucket> bucketTrees = createBuckets(32); final RevTree tree = RevObjectFactory.defaultInstance().createTree(id, size, childTreeCount, bucketTrees); RevTree roundTripped = (RevTree) read(tree.getId(), write(tree)); assertTreesAreEqual(tree, roundTripped); }
@Test public void testIntersects() { Node node = RevObjectFactory.defaultInstance().createNode("Points.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURE, new Envelope(0, 1, 2, 3), null); NodeRef nodeRef = NodeRef.create("Points", node); assertTrue(nodeRef.intersects(new Envelope(0, 0.5, 2, 2.5))); assertFalse(nodeRef.intersects(new Envelope(2, 3, 2, 3))); }