public @Override Bucket createBucket(@NonNull ObjectId bucketTree, int bucketIndex, @Nullable Envelope bounds) { if (bucketIndex < 0) { throw new IllegalArgumentException( "Bucket cannot have a negative index: " + bucketIndex); } return DEFAULT_IMPL.createBucket(bucketTree, bucketIndex, bounds); }
@Override protected final Bucket readBucketBody(int bucketIndex, DataInput in) throws IOException { ObjectId objectId = readObjectId(in); @Nullable final Envelope bounds = readBounds(in); return RevObjectFactory.defaultInstance().createBucket(objectId, bucketIndex, bounds); }
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 Bucket bucket(ObjectId bucketTree, int bucketIndex, Envelope bounds) { Bucket actual = factory.createBucket(bucketTree, bucketIndex, bounds); assertNotNull(actual); return actual; }
public ImmutableSortedMap<Integer, Bucket> build() { int off = offset + HEADER_SIZE; Builder<Integer, Bucket> builder = ImmutableSortedMap.naturalOrder(); DataInput in = data.asDataInput(off); try { int index; ObjectId id; double minx, maxx, miny, maxy; Envelope bounds; for (int i = 0; i < size; i++) { index = in.readUnsignedByte(); id = ObjectId.readFrom(in); minx = in.readDouble(); if (Double.isNaN(minx)) { bounds = null; } else { maxx = in.readDouble(); miny = in.readDouble(); maxy = in.readDouble(); bounds = new Envelope(minx, maxx, miny, maxy); } Bucket bucket = RevObjectFactory.defaultInstance().createBucket(id, index, bounds); builder.put(Integer.valueOf(index), bucket); } } catch (IOException e) { throw new RuntimeException(e); } return builder.build(); }
/** * Reads a bucket body (i.e assumes the head unsigned int "index" has been read already) * * @param bucketIndex */ protected Bucket readBucketBody(int bucketIndex, DataInput in) throws IOException { ObjectId objectId = readObjectId(in); final int boundsMask = in.readByte() & 0xFF; @Nullable final Envelope bounds; if (BOUNDS_POINT_MASK == boundsMask) { bounds = readPointBoundingBox(in); } else if (BOUNDS_BOX2D_MASK == boundsMask) { bounds = readBoundingBox(in); } else { bounds = null; } return RevObjectFactory.defaultInstance().createBucket(objectId, bucketIndex, bounds); }
private Bucket create(ObjectId id, Envelope bounds) { return RevObjectFactory.defaultInstance().createBucket(id, 0, bounds); }
ObjectId bucketId = ObjectId.valueOf(tokens.get(2)); Envelope bounds = parseBBox(tokens.get(3)); Bucket bucket = RevObjectFactory.defaultInstance().createBucket(bucketId, idx.intValue(), bounds); subtrees.add(bucket);
private Bucket testCreateBucket(ObjectId bucketTree, int bucketIndex, Envelope bounds) { Bucket actual = bucket(bucketTree, bucketIndex, bounds); Bucket expected = DEFAULT.createBucket(bucketTree, bucketIndex, bounds); RevObjectTestUtil.deepEquals(expected, actual); return actual; }
private SortedSet<Bucket> createBuckets(int count) { SortedSet<Bucket> buckets = new TreeSet<>(); for (int i = 0; i < count; i++) { Bucket bucket = RevObjectFactory.defaultInstance().createBucket( RevObjectTestSupport.hashString("b" + i), i, new Envelope(i, i * 2, i, i * 2)); buckets.add(bucket); } return buckets; }
private RevTree createBucketTree(int i) { final int bucketCount = 32; SortedSet<Bucket> buckets = new TreeSet<>(); for (int b = 0; b < bucketCount; b++) { ObjectId bucketTree = RevObjectTestSupport.hashString("b" + b); Envelope bounds = new Envelope(0, b, 0, b); Bucket bucket = objectFactory.createBucket(bucketTree, b, bounds); buckets.add(bucket); } final ObjectId fakeId = RevObjectTestSupport.hashString(String.valueOf(i)); RevTree tree = objectFactory.createTree(fakeId, 1024, 0, buckets); return tree; }
private RevTree createBucketTree(int i) { final int bucketCount = 32; SortedSet<Bucket> buckets = new TreeSet<>(); for (int b = 0; b < bucketCount; b++) { ObjectId bucketTree = RevObjectTestSupport.hashString("b" + b); Envelope bounds = new Envelope(0, b, 0, b); Bucket bucket = RevObjectFactory.defaultInstance().createBucket(bucketTree, 0, bounds); buckets.add(bucket); } final ObjectId fakeId = RevObjectTestSupport.hashString(String.valueOf(i)); RevTree tree = RevObjectFactory.defaultInstance().createTree(fakeId, 1024, 0, buckets); return tree; }
@Test public void testBucketsTree() throws IOException { RevTree tree; SortedSet<Bucket> buckets = new TreeSet<>(); buckets.add(RevObjectFactory.defaultInstance().createBucket(hashString("b1"), 1, null)); tree = tree(1024, null, null, buckets); encodeDecode(tree); }
childTreeCount += bucketTree.numTrees(); Bucket bucket = RevObjectFactory.defaultInstance().createBucket( bucketTree.getId(), bucketIndex, RevObjects.boundsOf(bucketTree));
@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); }
@Before public void before() { ObjectId oid = hashString("id"); ObjectId metadataId = hashString("metadata"); Envelope bounds = new Envelope(0, 180, 0, 90); Map<String, Object> materializedAttributes = new HashMap<>(); materializedAttributes.put("int", 1); materializedAttributes.put("double", 0.5); materializedAttributes.put("date", DATE_VALUE); materializedAttributes.put("string", "geogig"); materializedAttributes.put("nullprop", null); filterSplitter = new PrePostFilterSplitter() .extraAttributes(materializedAttributes.keySet()); Map<String, Object> extraData = ImmutableMap.of(IndexInfo.FEATURE_ATTRIBUTES_EXTRA_DATA, materializedAttributes); testNode = RevObjectFactory.defaultInstance().createNode("testFid", oid, metadataId, TYPE.FEATURE, bounds, extraData); testNodeRef = new NodeRef(testNode, "fakeLayerName", metadataId); ObjectId bucketId = hashString("bucketId"); testBucket = RevObjectFactory.defaultInstance().createBucket(bucketId, 0, bounds); }
RevTree leaf = createLeafTree(nodes); store.put(leaf); Bucket bucket = RevObjectFactory.defaultInstance().createBucket(leaf.getId(), bucketIndex.intValue(), SpatialOps.boundsOf(leaf)); buckets.add(bucket);
@Before public void before() { ObjectId oid = hashString("id"); ObjectId metadataId = hashString("metadata"); Envelope bounds = new Envelope(0, 180, 0, 90); Map<String, Object> materializedAttributes = ImmutableMap.of(// "int", 1, // "double", 0.5, // "date", new Date(1486344231314L)); Map<String, Object> extraData = ImmutableMap.of(IndexInfo.FEATURE_ATTRIBUTES_EXTRA_DATA, materializedAttributes); testNode = RevObjectFactory.defaultInstance().createNode("test", oid, metadataId, TYPE.FEATURE, bounds, extraData); testNodeRef = new NodeRef(testNode, "fakeLayerName", metadataId); ObjectId bucketId = hashString("bucketId"); testBucket = RevObjectFactory.defaultInstance().createBucket(bucketId, 0, bounds); }
ObjectId.valueOf("abc123000000000000001234567890abcdef0001"), ObjectId.NULL, TYPE.TREE, null, null); final Bucket testBucket = RevObjectFactory.defaultInstance().createBucket( ObjectId.valueOf("abc123000000000000001234567890abcdef0002"), 0, new Envelope(0, 0, 1, 1));
.createBucket(RevObjectTestSupport.hashString("buckettree"), 1, new Envelope())); .createBucket(RevObjectTestSupport.hashString("buckettree"), 1, new Envelope(1, 2, 1, 2)));