@Override public byte[] decode(PositionedByteRange src) { return decode(src, src.getRemaining()); }
@Override public int skip(PositionedByteRange src) { int skipped = src.getRemaining(); src.setPosition(src.getLength()); return skipped; }
@Override public int skip(PositionedByteRange src) { int skipped = src.getRemaining(); src.setPosition(src.getLength()); return skipped; }
@Override public String decode(PositionedByteRange src) { if (Order.ASCENDING == this.order) { // avoid unnecessary array copy for ASC case. String val = Bytes.toString(src.getBytes(), src.getOffset() + src.getPosition(), src.getRemaining()); src.setPosition(src.getLength()); return val; } else { byte[] b = new byte[src.getRemaining()]; src.get(b); order.apply(b, 0, b.length); return Bytes.toString(b); } }
@Override public int encode(PositionedByteRange dst, T val) { if (dst.getRemaining() < length) { throw new IllegalArgumentException("Not enough buffer remaining. dst.offset: " + dst.getOffset() + " dst.length: " + dst.getLength() + " dst.position: " + dst.getPosition() + " max length: " + length); } int written = base.encode(dst, val); if (written > length) { throw new IllegalArgumentException("Length of encoded value (" + written + ") exceeds max length (" + length + ")."); } // TODO: is the zero-padding appropriate? for (; written < length; written++) { dst.put((byte) 0x00); } return written; } }
/** * Create a {@link CodedInputStream} from a {@link PositionedByteRange}. Be sure to update * {@code src}'s position after consuming from the stream. * <p>For example: * <pre> * Foo.Builder builder = ... * CodedInputStream is = inputStreamFromByteRange(src); * Foo ret = builder.mergeFrom(is).build(); * src.setPosition(src.getPosition() + is.getTotalBytesRead()); * </pre> */ public static CodedInputStream inputStreamFromByteRange(PositionedByteRange src) { return CodedInputStream.newInstance( src.getBytes(), src.getOffset() + src.getPosition(), src.getRemaining()); }
final int start = src.getPosition(), offset = src.getOffset(), remaining = src.getRemaining(); Order ord = comp ? DESCENDING : ASCENDING; BigDecimal m = BigDecimal.ZERO;
@Override public T decode(PositionedByteRange src) { if (src.getRemaining() < length) { throw new IllegalArgumentException("Not enough buffer remaining. src.offset: " + src.getOffset() + " src.length: " + src.getLength() + " src.position: " + src.getPosition() + " max length: " + length); } // create a copy range limited to length bytes. boo. PositionedByteRange b = new SimplePositionedMutableByteRange(length); src.get(b.getBytes()); return base.decode(b); }
/** * Create a {@link CodedOutputStream} from a {@link PositionedByteRange}. Be sure to update * {@code dst}'s position after writing to the stream. * <p>For example: * <pre> * CodedOutputStream os = outputStreamFromByteRange(dst); * int before = os.spaceLeft(), after, written; * val.writeTo(os); * after = os.spaceLeft(); * written = before - after; * dst.setPosition(dst.getPosition() + written); * </pre> */ public static CodedOutputStream outputStreamFromByteRange(PositionedByteRange dst) { return CodedOutputStream.newInstance( dst.getBytes(), dst.getOffset() + dst.getPosition(), dst.getRemaining() ); } }
/** * Decode a Blob value, byte-for-byte copy. * @see #encodeBlobCopy(PositionedByteRange, byte[], int, int, Order) */ public static byte[] decodeBlobCopy(PositionedByteRange src) { byte header = src.get(); if (header == NULL || header == DESCENDING.apply(NULL)) { return null; } assert header == BLOB_COPY || header == DESCENDING.apply(BLOB_COPY); Order ord = header == BLOB_COPY ? ASCENDING : DESCENDING; final int length = src.getRemaining() - (ASCENDING == ord ? 0 : 1); byte[] ret = new byte[length]; src.get(ret); ord.apply(ret, 0, ret.length); // DESCENDING ordered BlobCopy requires a termination bit to preserve // sort-order semantics of null values. if (DESCENDING == ord) src.get(); return ret; }
assert dst.getRemaining() >= vlen + (ASCENDING == ord ? 1 : 2); if (DESCENDING == ord) { for (int i = 0; i < vlen; i++) {
assert dst.getRemaining() >= blobVarEncodedLength(vlen) : "buffer overflow expected."; final int offset = dst.getOffset(), start = dst.getPosition(); dst.put(BLOB_VAR);
assert src.getRemaining() >= lengthVaruint64(src, comp); final long ret; Order ord = comp ? DESCENDING : ASCENDING;
@Override public int skip(PositionedByteRange src) { int skipped = src.getRemaining(); src.setPosition(src.getLength()); return skipped; }
@Override public T decode(PositionedByteRange src) { if (src.getRemaining() < length) { throw new IllegalArgumentException("Not enough buffer remaining. src.offset: " + src.getOffset() + " src.length: " + src.getLength() + " src.position: " + src.getPosition() + " max length: " + length); } // create a copy range limited to length bytes. boo. PositionedByteRange b = new SimplePositionedMutableByteRange(length); src.get(b.getBytes()); return base.decode(b); }
@Override public T decode(PositionedByteRange src) { if (src.getRemaining() < length) { throw new IllegalArgumentException("Not enough buffer remaining. src.offset: " + src.getOffset() + " src.length: " + src.getLength() + " src.position: " + src.getPosition() + " max length: " + length); } // create a copy range limited to length bytes. boo. PositionedByteRange b = new SimplePositionedMutableByteRange(length); src.get(b.getBytes()); return base.decode(b); }
public static byte[] serialize(Object o) { PositionedByteRange buffer = new DynamicPositionedMutableByteRange(4096); serialize(buffer, o); buffer.setLength(buffer.getPosition()); buffer.setPosition(0); byte[] bytes = new byte[buffer.getRemaining()]; buffer.get(bytes); return bytes; }
public static byte[] serializeWithSalt(Object o) { PositionedByteRange buffer = new DynamicPositionedMutableByteRange(4096); serializeWithSalt(buffer, o); buffer.setLength(buffer.getPosition()); buffer.setPosition(0); byte[] bytes = new byte[buffer.getRemaining()]; buffer.get(bytes); return bytes; }
public byte[] serialize(String outVertexLabel, String edgeLabel, String inVertexLabel) { PositionedByteRange buffer = new DynamicPositionedMutableByteRange(4096); OrderedBytes.encodeString(buffer, outVertexLabel, Order.ASCENDING); OrderedBytes.encodeString(buffer, edgeLabel, Order.ASCENDING); OrderedBytes.encodeString(buffer, inVertexLabel, Order.ASCENDING); buffer.setLength(buffer.getPosition()); buffer.setPosition(0); byte[] bytes = new byte[buffer.getRemaining()]; buffer.get(bytes); return bytes; }
public byte[] serialize(LabelMetadata.Key label) { PositionedByteRange buffer = new DynamicPositionedMutableByteRange(4096); OrderedBytes.encodeString(buffer, label.label(), Order.ASCENDING); OrderedBytes.encodeInt8(buffer, label.type() == ElementType.VERTEX ? (byte) 1 : (byte) 0, Order.ASCENDING); buffer.setLength(buffer.getPosition()); buffer.setPosition(0); byte[] bytes = new byte[buffer.getRemaining()]; buffer.get(bytes); return bytes; }