private Node createNode(String name, ObjectId oid, ObjectId metadataId, TYPE type, Envelope bounds, Map<String, Object> extraData) { Node actual = factory.createNode(name, oid, metadataId, type, bounds, extraData); return actual; }
/** * @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); } }
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()); }
private Node treeNode(String name, ObjectId treeId, @Nullable ObjectId metadataId) { if (metadataId == null) { metadataId = ObjectId.NULL; } Node node = RevObjectFactory.defaultInstance().createNode(name, treeId, metadataId, TYPE.TREE, null, null); return node; }
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); } }
public void testCreateNode(String name, ObjectId oid, ObjectId metadataId, TYPE type, @Nullable Envelope bounds, @Nullable Map<String, Object> extraData) { Node actual = createNode(name, oid, metadataId, type, bounds, extraData); assertNotNull(actual); Node expected = DEFAULT.createNode(name, oid, metadataId, type, bounds, extraData); RevObjectTestUtil.deepEquals(expected, actual); }
private Node createNode(int n) { String name = "Node-" + n; ObjectId oid = RevObjectTestSupport.hashString(name); Envelope bounds = new Envelope(-1 * n, n, -1 * n, n); return objectFactory.createNode(name, oid, ObjectId.NULL, TYPE.FEATURE, bounds, null); }
protected Node createNode(int i) { String key = "Feature." + i; // ObjectId oid = ObjectId.forString(key); // ObjectId metadataId = ObjectId.forString("FeatureType"); // Node ref = new Node(key, oid, metadataId, TYPE.FEATURE); Node ref = RevObjectFactory.defaultInstance().createNode(key, FAKE_ID, FAKE_ID, TYPE.FEATURE, new Envelope(i, i + 1, i, i + 1), null); return ref; }
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)); }
/** * Creates a root node for the given tree as the one {@link PreOrderDiffWalk} should use to * start the traversal */ private 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 testToString() { Node node = RevObjectFactory.defaultInstance().createNode("Points.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURE, null, null); String readableNode = node.toString(); String expected = RevObjects.toString(node); assertEquals(expected, readableNode.toString()); }
@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); }
private DiffEntry entry(String name, RevFeature l, RevFeature r) { //@formatter:off Node lnode = l == null? null: RevObjectFactory.defaultInstance().createNode(name, l.getId(), ObjectId.NULL, TYPE.FEATURE, SpatialOps.boundsOf(l), null); Node rnode = r == null? null: RevObjectFactory.defaultInstance().createNode(name, r.getId(), ObjectId.NULL, TYPE.FEATURE, SpatialOps.boundsOf(r), null); //@formatter:on NodeRef oldObject = lnode == null ? null : NodeRef.create(NodeRef.ROOT, lnode); NodeRef newObject = rnode == null ? null : NodeRef.create(NodeRef.ROOT, rnode); return new DiffEntry(oldObject, newObject); }
@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); }
@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; }
private Node feature(ObjectStore db, String idPrefix, int index) { final String id = idPrefix + "." + index; final Feature feature; feature = super.feature(pointsType, id, id, index, point(index)); RevFeature revFeature = RevFeature.builder().build(feature); db.put(revFeature); Envelope bounds = (Envelope) feature.getBounds(); return RevObjectFactory.defaultInstance().createNode(id, revFeature.getId(), ObjectId.NULL, TYPE.FEATURE, bounds, null); }
@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))); }