@Override public void write(RevObject o, OutputStream out) throws IOException { final int storageVersionHeader = maxFormatCode; out.write(storageVersionHeader); writer.write(o, out); }
@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); }
@Override public String getDisplayName() { return factory.getDisplayName() + "/LZ4"; } }
@Test public void testStreaming() throws IOException { Assume.assumeTrue(serializer.supportsStreaming()); serializer.write(o, out); assertFalse(closed.get()); RevObject actual; try { actual = serializer.read(expected.getId(), in); assertFalse(closed.get()); assertEquals("at index " + i, 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); }
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); } }
private byte[] encode(RevObject obj) { ByteArrayOutputStream out = new ByteArrayOutputStream(); try { encoder.write(obj, out); } catch (IOException e) { throw new RuntimeException(e); } byte[] byteArray = out.toByteArray(); return byteArray; }
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 String getDisplayName() { return factory.getDisplayName() + "/LZF"; } }
@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); }
private byte[] encode(RevObject obj) { ByteArrayOutputStream out = new ByteArrayOutputStream(); try { encoder.write(obj, out); } catch (IOException e) { throw new RuntimeException(e); } return out.toByteArray(); }
@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 String getDisplayName() { StringBuilder sb = new StringBuilder("Proxy["); for (RevObjectSerializer f : supportedFormats) { sb.append(f.getDisplayName()).append(", "); } if (sb.length() > 2) { sb.setLength(sb.length() - 2); } sb.append(']'); return sb.toString(); }
@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())); }
protected void writeObject(RevObject object, OutputStream target) { try { serializer().write(object, target); } 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; }
public void run(RevObjectSerializer encoder, List<? extends RevObject> objects) { // cache.setEncoder(encoder); final Stopwatch put = put(objects); try { Thread.currentThread().sleep(5000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } Collections.shuffle(objects); final Stopwatch get = Stopwatch.createStarted(); int hits = query(Lists.transform(objects, (f) -> f.getId())); get.stop(); System.err.printf("%s\t %,d\t %,d\t %s\t %s\t %,d\t %s\n", encoder.getDisplayName(), objects.size(), hits, put, get, CacheManager.INSTANCE.getSizeBytes(), ""/* cache.toString() */); }
@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()); }
@Override public void funnel(RevObject object) throws IOException { out.write(object.getId().getRawValue()); serializer.write(object, out); }