bufferBuilder.finish(fg); return bufferBuilder.dataBuffer();
private static <T, S extends Geometry> Node_ createNode(List<Entry<T, S>> entries, Func1<? super T, byte[]> serializer) { FlatBufferBuilder builder = new FlatBufferBuilder(0); builder.finish(FlatBuffersHelper.addEntries(entries, builder, serializer)); return Node_.getRootAsNode_(builder.dataBuffer()); }
Tree_.finishTree_Buffer(builder, t); ByteBuffer bb = builder.dataBuffer(); os.write(bb.array(), bb.position(), bb.remaining());
public byte[] encode(@NonNull RevObject o) { FlatBufferBuilder fbb = new FlatBufferBuilder(); encode(o, fbb); ByteBuffer dataBuffer = fbb.dataBuffer(); byte[] array = new byte[dataBuffer.remaining()]; dataBuffer.get(array); return array; }
public @Override @NonNull RevCommit createCommit(@NonNull ObjectId id, @NonNull ObjectId treeId, @NonNull List<ObjectId> parents, @NonNull RevPerson author, @NonNull RevPerson committer, @NonNull String message) { if (parents.indexOf(null) > -1) { throw new NullPointerException("null parent at index " + parents.indexOf(null)); } FlatBufferBuilder fbb = newBuilder(); int objOffset = encoder.writeCommit(fbb, treeId, parents, author, committer, message); encoder.writeRevisionObject(ObjectType.Commit, objOffset, fbb); return (RevCommit) encoder.decode(id, copy(fbb.dataBuffer())); }
public @Override @NonNull RevTag createTag(@NonNull ObjectId id, @NonNull String name, @NonNull ObjectId commitId, @NonNull String message, @NonNull RevPerson tagger) { FlatBufferBuilder fbb = newBuilder(); int objOffset = encoder.writeTag(fbb, name, commitId, message, tagger); encoder.writeRevisionObject(ObjectType.Tag, objOffset, fbb); return (RevTag) encoder.decode(id, copy(fbb.dataBuffer())); }
public byte[] toByteArray() { FlatBufferBuilder builder = new FlatBufferBuilder(); int schemaOffset = this.getSchema(builder); builder.finish(schemaOffset); ByteBuffer bb = builder.dataBuffer(); byte[] bytes = new byte[bb.remaining()]; bb.get(bytes); return bytes; }
public @Override @NonNull RevTree createTree(final @NonNull ObjectId id, final long size, @NonNull List<Node> trees, @NonNull List<Node> features) { FlatBufferBuilder fbb = newBuilder(); int objOffset = encoder.writeLeafTree(fbb, size, trees, features); encoder.writeRevisionObject(ObjectType.LeafTree, objOffset, fbb); return (RevTree) encoder.decode(id, copy(fbb.dataBuffer())); }
public @Override @NonNull RevTree createTree(final @NonNull ObjectId id, final long size, final int childTreeCount, @NonNull SortedSet<Bucket> buckets) { if (size < 0L) { throw new IllegalArgumentException("Cannot create a tree with negative size: " + size); } if (childTreeCount < 0L) { throw new IllegalArgumentException( "Cannot create a tree with negative child tree count: " + childTreeCount); } FlatBufferBuilder fbb = newBuilder(); int objOffset = encoder.writeNodeTree(fbb, size, childTreeCount, buckets); encoder.writeRevisionObject(ObjectType.NodeTree, objOffset, fbb); return (RevTree) encoder.decode(id, copy(fbb.dataBuffer())); }
public @Override @NonNull ValueArray createValueArray(@NonNull List<Object> values) { FlatBufferBuilder fbb = newBuilder(); encoder.writeValueArray(fbb, values); return encoder.decodeValueArray(copy(fbb.dataBuffer())); }
public @Override @NonNull RevFeature createFeature(@NonNull ObjectId id, @NonNull List<Object> values) { FlatBufferBuilder fbb = newBuilder(); int objOffset = encoder.writeFeature(fbb, values); encoder.writeRevisionObject(ObjectType.Feature, objOffset, fbb); return (RevFeature) encoder.decode(id, copy(fbb.dataBuffer())); }
public @Override void write(@NonNull RevObject o, @NonNull OutputStream out) throws IOException { final ByteBuffer dataBuffer; if (o instanceof FBRevObject) { dataBuffer = ((FBRevObject<?>) o).getTable().getByteBuffer().duplicate(); } else { FlatBufferBuilder fbb = WRITE_BUFFERS.get(); fbb.clear(); flatBuffers.encode(o, fbb); dataBuffer = fbb.dataBuffer(); } byte[] array; int off, len = dataBuffer.remaining(); if (dataBuffer.hasArray()) { array = dataBuffer.array(); off = dataBuffer.position(); } else { off = 0; array = new byte[len]; dataBuffer.get(array); } if (isLengthPrefixed()) { // write size in little endian (FlatBuffers is LE exclusively, so follow suite) out.write((len >>> 0) & 0xFF); out.write((len >>> 8) & 0xFF); out.write((len >>> 16) & 0xFF); out.write((len >>> 24) & 0xFF); } out.write(array, off, len); }
public byte[] encode(byte[] serializedWithoutWrap, Map<String, String> tags) { FlatBufferBuilder fbb = new FlatBufferBuilder(1024); int[] tagsArr = new int[tags.size()]; int i = 0; for (Map.Entry<String, String> entry : tags.entrySet()) { tagsArr[i] = _encodeEntry(entry, fbb); i++; } int tagsRef = FB_FilterWrap.createTagsVector(fbb, tagsArr); int dataRef = FB_FilterWrap.createDataVector(fbb, serializedWithoutWrap); int filterWrapRef = FB_FilterWrap.createFB_FilterWrap(fbb, tagsRef, dataRef); FB_FilterWrap.finishFB_FilterWrapBuffer(fbb, filterWrapRef); int buffer_start = fbb.dataBuffer().position(); int buffer_length = fbb.offset(); byte[] full_buffer = fbb.dataBuffer().array(); return Arrays.copyOfRange(full_buffer, buffer_start, buffer_start + buffer_length); }
public static ByteBuffer serialize(FBSerializable writer) { FlatBufferBuilder builder = new FlatBufferBuilder(); int root = writer.writeTo(builder); builder.finish(root); return builder.dataBuffer(); } }
private static <T, S extends Geometry> Node_ createNode(List<Entry<T, S>> entries, Func1<? super T, byte[]> serializer) { FlatBufferBuilder builder = new FlatBufferBuilder(0); builder.finish(FlatBuffersHelper.addEntries(entries, builder, serializer)); return Node_.getRootAsNode_(builder.dataBuffer()); }
public @Override @NonNull RevFeatureType createFeatureType(@NonNull ObjectId id, @NonNull FeatureType ftype) { Collection<PropertyDescriptor> descriptors = ftype.getDescriptors(); descriptors.forEach(d -> { Class<?> binding = d.getType().getBinding(); Objects.requireNonNull(binding, "got null binding for attribute " + d.getName().getLocalPart()); FieldType fieldType = FieldType.forBinding(binding); if (FieldType.NULL == fieldType || FieldType.UNKNOWN == fieldType) { String msg = String.format( "Attribute %s of FeatureType %s is of an unsupported type: %s", d.getName().getLocalPart(), ftype.getName().getLocalPart(), binding.getName()); throw new IllegalArgumentException(msg); } }); FlatBufferBuilder fbb = newBuilder(); int objOffset = encoder.writeSimpleFeatureType(fbb, (SimpleFeatureType) ftype); encoder.writeRevisionObject(ObjectType.SimpleFeatureType, objOffset, fbb); return (RevFeatureType) encoder.decode(id, copy(fbb.dataBuffer())); }
public FragmentWritableBatch( final QueryId queryId, final int sendMajorFragmentId, final int sendMinorFragmentId, final int receiveMajorFragmentId, ArrowRecordBatch recordBatch, final int... receiveMinorFragmentId){ this.buffers = recordBatch.getBuffers().toArray(new ByteBuf[0]); this.recordCount = recordBatch.getLength(); FlatBufferBuilder fbbuilder = new FlatBufferBuilder(); fbbuilder.finish(recordBatch.writeTo(fbbuilder)); ByteBuffer arrowRecordBatch = fbbuilder.dataBuffer(); final FragmentRecordBatch.Builder builder = FragmentRecordBatch.newBuilder() .setArrowRecordBatch(ByteString.copyFrom(arrowRecordBatch)) .setQueryId(queryId) .setReceivingMajorFragmentId(receiveMajorFragmentId) .setSendingMajorFragmentId(sendMajorFragmentId) .setSendingMinorFragmentId(sendMinorFragmentId); for(final int i : receiveMinorFragmentId){ builder.addReceivingMinorFragmentId(i); } this.header = builder.build(); }
/** * Serializes a message header. * * @param builder to write the flatbuf to * @param headerType headerType field * @param headerOffset header offset field * @param bodyLength body length field * @return the corresponding ByteBuffer */ public static ByteBuffer serializeMessage( FlatBufferBuilder builder, byte headerType, int headerOffset, int bodyLength) { Message.startMessage(builder); Message.addHeaderType(builder, headerType); Message.addHeader(builder, headerOffset); Message.addVersion(builder, MetadataVersion.V4); Message.addBodyLength(builder, bodyLength); builder.finish(Message.endMessage(builder)); return builder.dataBuffer(); }
public static Operand createOperand(Bytes key, byte[] value) { FlatBufferBuilder fbb = new FlatBufferBuilder(); int kVec = fbb.createByteVector(key.get()); int vVec; if (value != null) { vVec = fbb.createByteVector(value); } else { vVec = fbb.createByteVector(new byte[0]); } Operand.startOperand(fbb); Operand.addKey(fbb, kVec); Operand.addValue(fbb, vVec); fbb.finish(Operand.endOperand(fbb)); return Operand.getRootAsOperand(fbb.dataBuffer()); } }
Tree_.finishTree_Buffer(builder, t); ByteBuffer bb = builder.dataBuffer(); os.write(bb.array(), bb.position(), bb.remaining());