@Override public RevObject read(ObjectId id, InputStream in) throws IOException { final int serialVersionHeader = in.read(); assert serialVersionHeader >= 0 && serialVersionHeader <= maxFormatCode; final RevObjectSerializer serializer = serializer(id, serialVersionHeader); RevObject revObject = serializer.read(id, in); return revObject; }
@Override public RevObject read(ObjectId id, InputStream rawData) throws IOException { // decompress the stream LZFInputStream inflatedInputeStream = new LZFInputStream(CHUNK_DECODER, rawData); return factory.read(id, inflatedInputeStream); }
private RevObject decode(CacheKey key, byte[] val) { try { return encoder.read(key.id(), val, 0, val.length); } catch (IOException e) { throw new RuntimeException(e); } }
@Override public RevObject read(@Nullable ObjectId id, byte[] data, int offset, int length) throws IOException { byte[] decoded = LZFDecoder.decode(data, offset, length); return factory.read(id, decoded, 0, decoded.length); }
private RevObject decode(CacheKey key, byte[] val) { try { return encoder.read(key.id(), val, 0, val.length); } catch (IOException e) { throw new RuntimeException(e); } }
@Override public RevObject read(@Nullable ObjectId id, byte[] data, int offset, int length) { final int serialVersionHeader = data[offset] & 0xFF; assert serialVersionHeader >= 0 && serialVersionHeader <= maxFormatCode; final RevObjectSerializer serializer = serializer(id, serialVersionHeader); RevObject revObject; try { revObject = serializer.read(id, data, offset + 1, length - 1); } catch (IOException e) { throw new RuntimeException("Error reading object " + id, e); } return revObject; }
protected RevObject get(final ObjectId id, boolean failIfNotFound) { InputStream raw = getRaw(id, failIfNotFound); if (null == raw) { return null; } RevObject object; try { object = serializer().read(id, raw); } catch (IOException e) { throw new RuntimeException(e); } finally { Closeables.closeQuietly(raw); } return object; }
private RevObject read(ObjectId id, byte[] bytes) throws IOException { ByteArrayInputStream bin = new ByteArrayInputStream(bytes); RevObject obj = serializer.read(id, bin); RevObject obj2 = serializer.read(id, bytes, 0, bytes.length); assertEquals(obj, obj2); assertEqualsFully(obj, obj2); return obj; }
@Override public RevObject read(ObjectId id, InputStream in) throws IOException { LZ4FastDecompressor decompressor = lz4factory.fastDecompressor(); Checksum checksum = newChecksum(); LZ4BlockInputStream cin = new LZ4BlockInputStream(in, decompressor, checksum); return factory.read(id, cin); }
private void testCommit(RevCommit commit) throws IOException { ByteArrayOutputStream out = new ByteArrayOutputStream(); serializer.write(commit, out); RevObject read = serializer.read(commit.getId(), new ByteArrayInputStream(out.toByteArray())); assertEquals(commit, read); }
private @Nullable ObjectInfo<T> computeNext() { checkOpen(); try (RocksDBReference dbRef = dbhandle.getReference()) { while (noderefs.hasNext()) { final NodeRef ref = noderefs.next(); final ObjectId id = ref.getObjectId(); id.getRawValue(keybuff); final int size = dbRef.db().get(readOps, keybuff, valueBuff); if (RocksDB.NOT_FOUND == size) { listener.notFound(id); continue; } if (size > valueBuff.length) { valueBuff = dbRef.db().get(readOps, keybuff); } RevObject object = serializer().read(id, new ByteArrayInputStream(valueBuff)); if (type.isInstance(object)) { listener.found(id, Integer.valueOf(size)); return ObjectInfo.of(ref, type.cast(object)); } else { listener.notFound(id); } } } catch (Exception e) { throw new RuntimeException(e); } return null; } };
@Override protected T computeNext() { checkOpen(); try (RocksDBReference dbRef = dbhandle.getReference()) { while (oids.hasNext()) { ObjectId id = oids.next(); id.getRawValue(keybuff); final int size = dbRef.db().get(readOps, keybuff, valueBuff); if (RocksDB.NOT_FOUND == size) { listener.notFound(id); continue; } if (size > valueBuff.length) { valueBuff = dbRef.db().get(readOps, keybuff); } RevObject object; object = serializer().read(id, valueBuff, 0, size); if (type.isInstance(object)) { listener.found(id, Integer.valueOf(size)); return type.cast(object); } else { listener.notFound(id); } } } catch (Exception e) { throw new RuntimeException(e); } return endOfData(); } };
protected void testFeatureReadWrite(Feature feature) throws Exception { RevFeature newFeature = RevFeature.builder().build(feature); ByteArrayOutputStream output = new ByteArrayOutputStream(); serializer.write(newFeature, output); byte[] data = output.toByteArray(); assertTrue(data.length > 0); ByteArrayInputStream input = new ByteArrayInputStream(data); RevFeature feat = (RevFeature) serializer.read(newFeature.getId(), input); assertNotNull(feat); assertEquals(newFeature.getValues().size(), feat.getValues().size()); for (int i = 0; i < newFeature.getValues().size(); i++) { Object expected = newFeature.getValues().get(i).orNull(); String msg = "At index " + i + ": " + (expected == null ? null : expected.getClass().getSimpleName()); Object actual = feat.get(i).orNull(); assertEquals(msg, expected, actual); } }
@Test public void testSerializerDoesntCloseStreams() throws IOException { AtomicBoolean closed = new AtomicBoolean(false); ByteArrayOutputStream out = new ByteArrayOutputStream() { public @Override void close() { closed.set(true); } }; final RevTree orig = tree1_leaves; serializer.write(orig, out); assertFalse(closed.get()); out.close(); assertTrue(closed.get()); closed.set(false); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()) { public @Override void close() throws IOException { closed.set(true); } }; final RevObject read = serializer.read(orig.getId(), in); assertFalse(closed.get()); assertEquals(orig, read); }
@Test public void testLargeStringValue() throws Exception { SimpleFeatureType type = DataUtilities.createType("LongStringType", "clob:String"); final int length = 256 * 1024; final String largeString = Strings.repeat("a", length); Feature feature = feature(type, "fid1", largeString); RevFeature revFeature = RevFeature.builder().build(feature); ByteArrayOutputStream output = new ByteArrayOutputStream(); serializer.write(revFeature, output); byte[] data = output.toByteArray(); ByteArrayInputStream input = new ByteArrayInputStream(data); RevFeature feat = (RevFeature) serializer.read(revFeature.getId(), input); assertNotNull(feat); assertEquals(1, feat.getValues().size()); Optional<Object> value = feat.getValues().get(0); assertTrue(value.isPresent()); String deserialized = (String) value.get(); assertEquals(largeString.length(), deserialized.length()); assertEquals(largeString, deserialized); }
RevObject actual; try { actual = serializer.read(expected.getId(), in); assertFalse(closed.get()); assertEquals("at index " + i, expected, actual);
@Test public void testFeatureTypeSerialization() throws Exception { RevFeatureType revFeatureType = RevFeatureType.builder().type(featureType).build(); ByteArrayOutputStream output = new ByteArrayOutputStream(); serializer.write(revFeatureType, output); byte[] data = output.toByteArray(); assertTrue(data.length > 0); ByteArrayInputStream input = new ByteArrayInputStream(data); RevFeatureType rft = (RevFeatureType) serializer.read(revFeatureType.getId(), input); assertNotNull(rft); SimpleFeatureType serializedFeatureType = (SimpleFeatureType) rft.type(); assertEquals(serializedFeatureType.getDescriptors().size(), featureType.getDescriptors().size()); for (int i = 0; i < featureType.getDescriptors().size(); i++) { assertEquals(featureType.getDescriptor(i), serializedFeatureType.getDescriptor(i)); } assertEquals(featureType.getGeometryDescriptor(), serializedFeatureType.getGeometryDescriptor()); assertEquals(featureType.getCoordinateReferenceSystem(), serializedFeatureType.getCoordinateReferenceSystem()); }
@Test public void testFeatureTypeSerializationWGS84() throws Exception { SimpleFeatureTypeBuilder ftb = new SimpleFeatureTypeBuilder(); ftb.add("geom", Polygon.class, DefaultGeographicCRS.WGS84); ftb.setName("type"); SimpleFeatureType ftype = ftb.buildFeatureType(); RevFeatureType revFeatureType = RevFeatureType.builder().type(ftype).build(); ByteArrayOutputStream output = new ByteArrayOutputStream(); serializer.write(revFeatureType, output); byte[] data = output.toByteArray(); assertTrue(data.length > 0); ByteArrayInputStream input = new ByteArrayInputStream(data); RevFeatureType rft = (RevFeatureType) serializer.read(revFeatureType.getId(), input); assertNotNull(rft); FeatureType serializedFeatureType = rft.type(); assertEquals("EPSG:4326", CRS.toSRS(serializedFeatureType.getCoordinateReferenceSystem())); }