| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| |
| #![allow(dead_code)] |
| #![allow(unused_imports)] |
| |
| use crate::ipc::gen::Schema::*; |
| use crate::ipc::gen::SparseTensor::*; |
| use crate::ipc::gen::Tensor::*; |
| use flatbuffers::EndianScalar; |
| use std::{cmp::Ordering, mem}; |
| // automatically generated by the FlatBuffers compiler, do not modify |
| |
| #[deprecated( |
| since = "2.0.0", |
| note = "Use associated constants instead. This will no longer be generated in 2021." |
| )] |
| pub const ENUM_MIN_COMPRESSION_TYPE: i8 = 0; |
| #[deprecated( |
| since = "2.0.0", |
| note = "Use associated constants instead. This will no longer be generated in 2021." |
| )] |
| pub const ENUM_MAX_COMPRESSION_TYPE: i8 = 1; |
| #[deprecated( |
| since = "2.0.0", |
| note = "Use associated constants instead. This will no longer be generated in 2021." |
| )] |
| #[allow(non_camel_case_types)] |
| pub const ENUM_VALUES_COMPRESSION_TYPE: [CompressionType; 2] = |
| [CompressionType::LZ4_FRAME, CompressionType::ZSTD]; |
| |
| #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] |
| #[repr(transparent)] |
| pub struct CompressionType(pub i8); |
| #[allow(non_upper_case_globals)] |
| impl CompressionType { |
| pub const LZ4_FRAME: Self = Self(0); |
| pub const ZSTD: Self = Self(1); |
| |
| pub const ENUM_MIN: i8 = 0; |
| pub const ENUM_MAX: i8 = 1; |
| pub const ENUM_VALUES: &'static [Self] = &[Self::LZ4_FRAME, Self::ZSTD]; |
| /// Returns the variant's name or "" if unknown. |
| pub fn variant_name(self) -> Option<&'static str> { |
| match self { |
| Self::LZ4_FRAME => Some("LZ4_FRAME"), |
| Self::ZSTD => Some("ZSTD"), |
| _ => None, |
| } |
| } |
| } |
| impl std::fmt::Debug for CompressionType { |
| fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { |
| if let Some(name) = self.variant_name() { |
| f.write_str(name) |
| } else { |
| f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0)) |
| } |
| } |
| } |
| impl<'a> flatbuffers::Follow<'a> for CompressionType { |
| type Inner = Self; |
| #[inline] |
| fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { |
| let b = flatbuffers::read_scalar_at::<i8>(buf, loc); |
| Self(b) |
| } |
| } |
| |
| impl flatbuffers::Push for CompressionType { |
| type Output = CompressionType; |
| #[inline] |
| fn push(&self, dst: &mut [u8], _rest: &[u8]) { |
| flatbuffers::emplace_scalar::<i8>(dst, self.0); |
| } |
| } |
| |
| impl flatbuffers::EndianScalar for CompressionType { |
| #[inline] |
| fn to_little_endian(self) -> Self { |
| let b = i8::to_le(self.0); |
| Self(b) |
| } |
| #[inline] |
| fn from_little_endian(self) -> Self { |
| let b = i8::from_le(self.0); |
| Self(b) |
| } |
| } |
| |
| impl<'a> flatbuffers::Verifiable for CompressionType { |
| #[inline] |
| fn run_verifier( |
| v: &mut flatbuffers::Verifier, |
| pos: usize, |
| ) -> Result<(), flatbuffers::InvalidFlatbuffer> { |
| use flatbuffers::Verifiable; |
| i8::run_verifier(v, pos) |
| } |
| } |
| |
| impl flatbuffers::SimpleToVerifyInSlice for CompressionType {} |
| #[deprecated( |
| since = "2.0.0", |
| note = "Use associated constants instead. This will no longer be generated in 2021." |
| )] |
| pub const ENUM_MIN_BODY_COMPRESSION_METHOD: i8 = 0; |
| #[deprecated( |
| since = "2.0.0", |
| note = "Use associated constants instead. This will no longer be generated in 2021." |
| )] |
| pub const ENUM_MAX_BODY_COMPRESSION_METHOD: i8 = 0; |
| #[deprecated( |
| since = "2.0.0", |
| note = "Use associated constants instead. This will no longer be generated in 2021." |
| )] |
| #[allow(non_camel_case_types)] |
| pub const ENUM_VALUES_BODY_COMPRESSION_METHOD: [BodyCompressionMethod; 1] = |
| [BodyCompressionMethod::BUFFER]; |
| |
| /// Provided for forward compatibility in case we need to support different |
| /// strategies for compressing the IPC message body (like whole-body |
| /// compression rather than buffer-level) in the future |
| #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] |
| #[repr(transparent)] |
| pub struct BodyCompressionMethod(pub i8); |
| #[allow(non_upper_case_globals)] |
| impl BodyCompressionMethod { |
| /// Each constituent buffer is first compressed with the indicated |
| /// compressor, and then written with the uncompressed length in the first 8 |
| /// bytes as a 64-bit little-endian signed integer followed by the compressed |
| /// buffer bytes (and then padding as required by the protocol). The |
| /// uncompressed length may be set to -1 to indicate that the data that |
| /// follows is not compressed, which can be useful for cases where |
| /// compression does not yield appreciable savings. |
| pub const BUFFER: Self = Self(0); |
| |
| pub const ENUM_MIN: i8 = 0; |
| pub const ENUM_MAX: i8 = 0; |
| pub const ENUM_VALUES: &'static [Self] = &[Self::BUFFER]; |
| /// Returns the variant's name or "" if unknown. |
| pub fn variant_name(self) -> Option<&'static str> { |
| match self { |
| Self::BUFFER => Some("BUFFER"), |
| _ => None, |
| } |
| } |
| } |
| impl std::fmt::Debug for BodyCompressionMethod { |
| fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { |
| if let Some(name) = self.variant_name() { |
| f.write_str(name) |
| } else { |
| f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0)) |
| } |
| } |
| } |
| impl<'a> flatbuffers::Follow<'a> for BodyCompressionMethod { |
| type Inner = Self; |
| #[inline] |
| fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { |
| let b = flatbuffers::read_scalar_at::<i8>(buf, loc); |
| Self(b) |
| } |
| } |
| |
| impl flatbuffers::Push for BodyCompressionMethod { |
| type Output = BodyCompressionMethod; |
| #[inline] |
| fn push(&self, dst: &mut [u8], _rest: &[u8]) { |
| flatbuffers::emplace_scalar::<i8>(dst, self.0); |
| } |
| } |
| |
| impl flatbuffers::EndianScalar for BodyCompressionMethod { |
| #[inline] |
| fn to_little_endian(self) -> Self { |
| let b = i8::to_le(self.0); |
| Self(b) |
| } |
| #[inline] |
| fn from_little_endian(self) -> Self { |
| let b = i8::from_le(self.0); |
| Self(b) |
| } |
| } |
| |
| impl<'a> flatbuffers::Verifiable for BodyCompressionMethod { |
| #[inline] |
| fn run_verifier( |
| v: &mut flatbuffers::Verifier, |
| pos: usize, |
| ) -> Result<(), flatbuffers::InvalidFlatbuffer> { |
| use flatbuffers::Verifiable; |
| i8::run_verifier(v, pos) |
| } |
| } |
| |
| impl flatbuffers::SimpleToVerifyInSlice for BodyCompressionMethod {} |
| #[deprecated( |
| since = "2.0.0", |
| note = "Use associated constants instead. This will no longer be generated in 2021." |
| )] |
| pub const ENUM_MIN_MESSAGE_HEADER: u8 = 0; |
| #[deprecated( |
| since = "2.0.0", |
| note = "Use associated constants instead. This will no longer be generated in 2021." |
| )] |
| pub const ENUM_MAX_MESSAGE_HEADER: u8 = 5; |
| #[deprecated( |
| since = "2.0.0", |
| note = "Use associated constants instead. This will no longer be generated in 2021." |
| )] |
| #[allow(non_camel_case_types)] |
| pub const ENUM_VALUES_MESSAGE_HEADER: [MessageHeader; 6] = [ |
| MessageHeader::NONE, |
| MessageHeader::Schema, |
| MessageHeader::DictionaryBatch, |
| MessageHeader::RecordBatch, |
| MessageHeader::Tensor, |
| MessageHeader::SparseTensor, |
| ]; |
| |
| /// ---------------------------------------------------------------------- |
| /// The root Message type |
| /// This union enables us to easily send different message types without |
| /// redundant storage, and in the future we can easily add new message types. |
| /// |
| /// Arrow implementations do not need to implement all of the message types, |
| /// which may include experimental metadata types. For maximum compatibility, |
| /// it is best to send data using RecordBatch |
| #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] |
| #[repr(transparent)] |
| pub struct MessageHeader(pub u8); |
| #[allow(non_upper_case_globals)] |
| impl MessageHeader { |
| pub const NONE: Self = Self(0); |
| pub const Schema: Self = Self(1); |
| pub const DictionaryBatch: Self = Self(2); |
| pub const RecordBatch: Self = Self(3); |
| pub const Tensor: Self = Self(4); |
| pub const SparseTensor: Self = Self(5); |
| |
| pub const ENUM_MIN: u8 = 0; |
| pub const ENUM_MAX: u8 = 5; |
| pub const ENUM_VALUES: &'static [Self] = &[ |
| Self::NONE, |
| Self::Schema, |
| Self::DictionaryBatch, |
| Self::RecordBatch, |
| Self::Tensor, |
| Self::SparseTensor, |
| ]; |
| /// Returns the variant's name or "" if unknown. |
| pub fn variant_name(self) -> Option<&'static str> { |
| match self { |
| Self::NONE => Some("NONE"), |
| Self::Schema => Some("Schema"), |
| Self::DictionaryBatch => Some("DictionaryBatch"), |
| Self::RecordBatch => Some("RecordBatch"), |
| Self::Tensor => Some("Tensor"), |
| Self::SparseTensor => Some("SparseTensor"), |
| _ => None, |
| } |
| } |
| } |
| impl std::fmt::Debug for MessageHeader { |
| fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { |
| if let Some(name) = self.variant_name() { |
| f.write_str(name) |
| } else { |
| f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0)) |
| } |
| } |
| } |
| pub struct MessageHeaderUnionTableOffset {} |
| impl<'a> flatbuffers::Follow<'a> for MessageHeader { |
| type Inner = Self; |
| #[inline] |
| fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { |
| let b = flatbuffers::read_scalar_at::<u8>(buf, loc); |
| Self(b) |
| } |
| } |
| |
| impl flatbuffers::Push for MessageHeader { |
| type Output = MessageHeader; |
| #[inline] |
| fn push(&self, dst: &mut [u8], _rest: &[u8]) { |
| flatbuffers::emplace_scalar::<u8>(dst, self.0); |
| } |
| } |
| |
| impl flatbuffers::EndianScalar for MessageHeader { |
| #[inline] |
| fn to_little_endian(self) -> Self { |
| let b = u8::to_le(self.0); |
| Self(b) |
| } |
| #[inline] |
| fn from_little_endian(self) -> Self { |
| let b = u8::from_le(self.0); |
| Self(b) |
| } |
| } |
| |
| impl<'a> flatbuffers::Verifiable for MessageHeader { |
| #[inline] |
| fn run_verifier( |
| v: &mut flatbuffers::Verifier, |
| pos: usize, |
| ) -> Result<(), flatbuffers::InvalidFlatbuffer> { |
| use flatbuffers::Verifiable; |
| u8::run_verifier(v, pos) |
| } |
| } |
| |
| impl flatbuffers::SimpleToVerifyInSlice for MessageHeader {} |
| /// ---------------------------------------------------------------------- |
| /// Data structures for describing a table row batch (a collection of |
| /// equal-length Arrow arrays) |
| /// Metadata about a field at some level of a nested type tree (but not |
| /// its children). |
| /// |
| /// For example, a List<Int16> with values `[[1, 2, 3], null, [4], [5, 6], null]` |
| /// would have {length: 5, null_count: 2} for its List node, and {length: 6, |
| /// null_count: 0} for its Int16 node, as separate FieldNode structs |
| // struct FieldNode, aligned to 8 |
| #[repr(transparent)] |
| #[derive(Clone, Copy, PartialEq)] |
| pub struct FieldNode(pub [u8; 16]); |
| impl std::fmt::Debug for FieldNode { |
| fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { |
| f.debug_struct("FieldNode") |
| .field("length", &self.length()) |
| .field("null_count", &self.null_count()) |
| .finish() |
| } |
| } |
| |
| impl flatbuffers::SimpleToVerifyInSlice for FieldNode {} |
| impl flatbuffers::SafeSliceAccess for FieldNode {} |
| impl<'a> flatbuffers::Follow<'a> for FieldNode { |
| type Inner = &'a FieldNode; |
| #[inline] |
| fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { |
| <&'a FieldNode>::follow(buf, loc) |
| } |
| } |
| impl<'a> flatbuffers::Follow<'a> for &'a FieldNode { |
| type Inner = &'a FieldNode; |
| #[inline] |
| fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { |
| flatbuffers::follow_cast_ref::<FieldNode>(buf, loc) |
| } |
| } |
| impl<'b> flatbuffers::Push for FieldNode { |
| type Output = FieldNode; |
| #[inline] |
| fn push(&self, dst: &mut [u8], _rest: &[u8]) { |
| let src = unsafe { |
| ::std::slice::from_raw_parts( |
| self as *const FieldNode as *const u8, |
| Self::size(), |
| ) |
| }; |
| dst.copy_from_slice(src); |
| } |
| } |
| impl<'b> flatbuffers::Push for &'b FieldNode { |
| type Output = FieldNode; |
| |
| #[inline] |
| fn push(&self, dst: &mut [u8], _rest: &[u8]) { |
| let src = unsafe { |
| ::std::slice::from_raw_parts( |
| *self as *const FieldNode as *const u8, |
| Self::size(), |
| ) |
| }; |
| dst.copy_from_slice(src); |
| } |
| } |
| |
| impl<'a> flatbuffers::Verifiable for FieldNode { |
| #[inline] |
| fn run_verifier( |
| v: &mut flatbuffers::Verifier, |
| pos: usize, |
| ) -> Result<(), flatbuffers::InvalidFlatbuffer> { |
| use flatbuffers::Verifiable; |
| v.in_buffer::<Self>(pos) |
| } |
| } |
| impl FieldNode { |
| #[allow(clippy::too_many_arguments)] |
| pub fn new(length: i64, null_count: i64) -> Self { |
| let mut s = Self([0; 16]); |
| s.set_length(length); |
| s.set_null_count(null_count); |
| s |
| } |
| |
| /// The number of value slots in the Arrow array at this level of a nested |
| /// tree |
| pub fn length(&self) -> i64 { |
| let mut mem = core::mem::MaybeUninit::<i64>::uninit(); |
| unsafe { |
| core::ptr::copy_nonoverlapping( |
| self.0[0..].as_ptr(), |
| mem.as_mut_ptr() as *mut u8, |
| core::mem::size_of::<i64>(), |
| ); |
| mem.assume_init() |
| } |
| .from_little_endian() |
| } |
| |
| pub fn set_length(&mut self, x: i64) { |
| let x_le = x.to_little_endian(); |
| unsafe { |
| core::ptr::copy_nonoverlapping( |
| &x_le as *const i64 as *const u8, |
| self.0[0..].as_mut_ptr(), |
| core::mem::size_of::<i64>(), |
| ); |
| } |
| } |
| |
| /// The number of observed nulls. Fields with null_count == 0 may choose not |
| /// to write their physical validity bitmap out as a materialized buffer, |
| /// instead setting the length of the bitmap buffer to 0. |
| pub fn null_count(&self) -> i64 { |
| let mut mem = core::mem::MaybeUninit::<i64>::uninit(); |
| unsafe { |
| core::ptr::copy_nonoverlapping( |
| self.0[8..].as_ptr(), |
| mem.as_mut_ptr() as *mut u8, |
| core::mem::size_of::<i64>(), |
| ); |
| mem.assume_init() |
| } |
| .from_little_endian() |
| } |
| |
| pub fn set_null_count(&mut self, x: i64) { |
| let x_le = x.to_little_endian(); |
| unsafe { |
| core::ptr::copy_nonoverlapping( |
| &x_le as *const i64 as *const u8, |
| self.0[8..].as_mut_ptr(), |
| core::mem::size_of::<i64>(), |
| ); |
| } |
| } |
| } |
| |
| pub enum BodyCompressionOffset {} |
| #[derive(Copy, Clone, PartialEq)] |
| |
| /// Optional compression for the memory buffers constituting IPC message |
| /// bodies. Intended for use with RecordBatch but could be used for other |
| /// message types |
| pub struct BodyCompression<'a> { |
| pub _tab: flatbuffers::Table<'a>, |
| } |
| |
| impl<'a> flatbuffers::Follow<'a> for BodyCompression<'a> { |
| type Inner = BodyCompression<'a>; |
| #[inline] |
| fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { |
| Self { |
| _tab: flatbuffers::Table { buf, loc }, |
| } |
| } |
| } |
| |
| impl<'a> BodyCompression<'a> { |
| #[inline] |
| pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { |
| BodyCompression { _tab: table } |
| } |
| #[allow(unused_mut)] |
| pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( |
| _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, |
| args: &'args BodyCompressionArgs, |
| ) -> flatbuffers::WIPOffset<BodyCompression<'bldr>> { |
| let mut builder = BodyCompressionBuilder::new(_fbb); |
| builder.add_method(args.method); |
| builder.add_codec(args.codec); |
| builder.finish() |
| } |
| |
| pub const VT_CODEC: flatbuffers::VOffsetT = 4; |
| pub const VT_METHOD: flatbuffers::VOffsetT = 6; |
| |
| /// Compressor library |
| #[inline] |
| pub fn codec(&self) -> CompressionType { |
| self._tab |
| .get::<CompressionType>( |
| BodyCompression::VT_CODEC, |
| Some(CompressionType::LZ4_FRAME), |
| ) |
| .unwrap() |
| } |
| /// Indicates the way the record batch body was compressed |
| #[inline] |
| pub fn method(&self) -> BodyCompressionMethod { |
| self._tab |
| .get::<BodyCompressionMethod>( |
| BodyCompression::VT_METHOD, |
| Some(BodyCompressionMethod::BUFFER), |
| ) |
| .unwrap() |
| } |
| } |
| |
| impl flatbuffers::Verifiable for BodyCompression<'_> { |
| #[inline] |
| fn run_verifier( |
| v: &mut flatbuffers::Verifier, |
| pos: usize, |
| ) -> Result<(), flatbuffers::InvalidFlatbuffer> { |
| use flatbuffers::Verifiable; |
| v.visit_table(pos)? |
| .visit_field::<CompressionType>(&"codec", Self::VT_CODEC, false)? |
| .visit_field::<BodyCompressionMethod>(&"method", Self::VT_METHOD, false)? |
| .finish(); |
| Ok(()) |
| } |
| } |
| pub struct BodyCompressionArgs { |
| pub codec: CompressionType, |
| pub method: BodyCompressionMethod, |
| } |
| impl<'a> Default for BodyCompressionArgs { |
| #[inline] |
| fn default() -> Self { |
| BodyCompressionArgs { |
| codec: CompressionType::LZ4_FRAME, |
| method: BodyCompressionMethod::BUFFER, |
| } |
| } |
| } |
| pub struct BodyCompressionBuilder<'a: 'b, 'b> { |
| fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, |
| } |
| impl<'a: 'b, 'b> BodyCompressionBuilder<'a, 'b> { |
| #[inline] |
| pub fn add_codec(&mut self, codec: CompressionType) { |
| self.fbb_.push_slot::<CompressionType>( |
| BodyCompression::VT_CODEC, |
| codec, |
| CompressionType::LZ4_FRAME, |
| ); |
| } |
| #[inline] |
| pub fn add_method(&mut self, method: BodyCompressionMethod) { |
| self.fbb_.push_slot::<BodyCompressionMethod>( |
| BodyCompression::VT_METHOD, |
| method, |
| BodyCompressionMethod::BUFFER, |
| ); |
| } |
| #[inline] |
| pub fn new( |
| _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| ) -> BodyCompressionBuilder<'a, 'b> { |
| let start = _fbb.start_table(); |
| BodyCompressionBuilder { |
| fbb_: _fbb, |
| start_: start, |
| } |
| } |
| #[inline] |
| pub fn finish(self) -> flatbuffers::WIPOffset<BodyCompression<'a>> { |
| let o = self.fbb_.end_table(self.start_); |
| flatbuffers::WIPOffset::new(o.value()) |
| } |
| } |
| |
| impl std::fmt::Debug for BodyCompression<'_> { |
| fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| let mut ds = f.debug_struct("BodyCompression"); |
| ds.field("codec", &self.codec()); |
| ds.field("method", &self.method()); |
| ds.finish() |
| } |
| } |
| pub enum RecordBatchOffset {} |
| #[derive(Copy, Clone, PartialEq)] |
| |
| /// A data header describing the shared memory layout of a "record" or "row" |
| /// batch. Some systems call this a "row batch" internally and others a "record |
| /// batch". |
| pub struct RecordBatch<'a> { |
| pub _tab: flatbuffers::Table<'a>, |
| } |
| |
| impl<'a> flatbuffers::Follow<'a> for RecordBatch<'a> { |
| type Inner = RecordBatch<'a>; |
| #[inline] |
| fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { |
| Self { |
| _tab: flatbuffers::Table { buf, loc }, |
| } |
| } |
| } |
| |
| impl<'a> RecordBatch<'a> { |
| #[inline] |
| pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { |
| RecordBatch { _tab: table } |
| } |
| #[allow(unused_mut)] |
| pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( |
| _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, |
| args: &'args RecordBatchArgs<'args>, |
| ) -> flatbuffers::WIPOffset<RecordBatch<'bldr>> { |
| let mut builder = RecordBatchBuilder::new(_fbb); |
| builder.add_length(args.length); |
| if let Some(x) = args.compression { |
| builder.add_compression(x); |
| } |
| if let Some(x) = args.buffers { |
| builder.add_buffers(x); |
| } |
| if let Some(x) = args.nodes { |
| builder.add_nodes(x); |
| } |
| builder.finish() |
| } |
| |
| pub const VT_LENGTH: flatbuffers::VOffsetT = 4; |
| pub const VT_NODES: flatbuffers::VOffsetT = 6; |
| pub const VT_BUFFERS: flatbuffers::VOffsetT = 8; |
| pub const VT_COMPRESSION: flatbuffers::VOffsetT = 10; |
| |
| /// number of records / rows. The arrays in the batch should all have this |
| /// length |
| #[inline] |
| pub fn length(&self) -> i64 { |
| self._tab |
| .get::<i64>(RecordBatch::VT_LENGTH, Some(0)) |
| .unwrap() |
| } |
| /// Nodes correspond to the pre-ordered flattened logical schema |
| #[inline] |
| pub fn nodes(&self) -> Option<&'a [FieldNode]> { |
| self._tab |
| .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, FieldNode>>>( |
| RecordBatch::VT_NODES, |
| None, |
| ) |
| .map(|v| v.safe_slice()) |
| } |
| /// Buffers correspond to the pre-ordered flattened buffer tree |
| /// |
| /// The number of buffers appended to this list depends on the schema. For |
| /// example, most primitive arrays will have 2 buffers, 1 for the validity |
| /// bitmap and 1 for the values. For struct arrays, there will only be a |
| /// single buffer for the validity (nulls) bitmap |
| #[inline] |
| pub fn buffers(&self) -> Option<&'a [Buffer]> { |
| self._tab |
| .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Buffer>>>( |
| RecordBatch::VT_BUFFERS, |
| None, |
| ) |
| .map(|v| v.safe_slice()) |
| } |
| /// Optional compression of the message body |
| #[inline] |
| pub fn compression(&self) -> Option<BodyCompression<'a>> { |
| self._tab |
| .get::<flatbuffers::ForwardsUOffset<BodyCompression>>( |
| RecordBatch::VT_COMPRESSION, |
| None, |
| ) |
| } |
| } |
| |
| impl flatbuffers::Verifiable for RecordBatch<'_> { |
| #[inline] |
| fn run_verifier( |
| v: &mut flatbuffers::Verifier, |
| pos: usize, |
| ) -> Result<(), flatbuffers::InvalidFlatbuffer> { |
| use flatbuffers::Verifiable; |
| v.visit_table(pos)? |
| .visit_field::<i64>(&"length", Self::VT_LENGTH, false)? |
| .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, FieldNode>>>(&"nodes", Self::VT_NODES, false)? |
| .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Buffer>>>(&"buffers", Self::VT_BUFFERS, false)? |
| .visit_field::<flatbuffers::ForwardsUOffset<BodyCompression>>(&"compression", Self::VT_COMPRESSION, false)? |
| .finish(); |
| Ok(()) |
| } |
| } |
| pub struct RecordBatchArgs<'a> { |
| pub length: i64, |
| pub nodes: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, FieldNode>>>, |
| pub buffers: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Buffer>>>, |
| pub compression: Option<flatbuffers::WIPOffset<BodyCompression<'a>>>, |
| } |
| impl<'a> Default for RecordBatchArgs<'a> { |
| #[inline] |
| fn default() -> Self { |
| RecordBatchArgs { |
| length: 0, |
| nodes: None, |
| buffers: None, |
| compression: None, |
| } |
| } |
| } |
| pub struct RecordBatchBuilder<'a: 'b, 'b> { |
| fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, |
| } |
| impl<'a: 'b, 'b> RecordBatchBuilder<'a, 'b> { |
| #[inline] |
| pub fn add_length(&mut self, length: i64) { |
| self.fbb_ |
| .push_slot::<i64>(RecordBatch::VT_LENGTH, length, 0); |
| } |
| #[inline] |
| pub fn add_nodes( |
| &mut self, |
| nodes: flatbuffers::WIPOffset<flatbuffers::Vector<'b, FieldNode>>, |
| ) { |
| self.fbb_ |
| .push_slot_always::<flatbuffers::WIPOffset<_>>(RecordBatch::VT_NODES, nodes); |
| } |
| #[inline] |
| pub fn add_buffers( |
| &mut self, |
| buffers: flatbuffers::WIPOffset<flatbuffers::Vector<'b, Buffer>>, |
| ) { |
| self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>( |
| RecordBatch::VT_BUFFERS, |
| buffers, |
| ); |
| } |
| #[inline] |
| pub fn add_compression( |
| &mut self, |
| compression: flatbuffers::WIPOffset<BodyCompression<'b>>, |
| ) { |
| self.fbb_ |
| .push_slot_always::<flatbuffers::WIPOffset<BodyCompression>>( |
| RecordBatch::VT_COMPRESSION, |
| compression, |
| ); |
| } |
| #[inline] |
| pub fn new( |
| _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| ) -> RecordBatchBuilder<'a, 'b> { |
| let start = _fbb.start_table(); |
| RecordBatchBuilder { |
| fbb_: _fbb, |
| start_: start, |
| } |
| } |
| #[inline] |
| pub fn finish(self) -> flatbuffers::WIPOffset<RecordBatch<'a>> { |
| let o = self.fbb_.end_table(self.start_); |
| flatbuffers::WIPOffset::new(o.value()) |
| } |
| } |
| |
| impl std::fmt::Debug for RecordBatch<'_> { |
| fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| let mut ds = f.debug_struct("RecordBatch"); |
| ds.field("length", &self.length()); |
| ds.field("nodes", &self.nodes()); |
| ds.field("buffers", &self.buffers()); |
| ds.field("compression", &self.compression()); |
| ds.finish() |
| } |
| } |
| pub enum DictionaryBatchOffset {} |
| #[derive(Copy, Clone, PartialEq)] |
| |
| /// For sending dictionary encoding information. Any Field can be |
| /// dictionary-encoded, but in this case none of its children may be |
| /// dictionary-encoded. |
| /// There is one vector / column per dictionary, but that vector / column |
| /// may be spread across multiple dictionary batches by using the isDelta |
| /// flag |
| pub struct DictionaryBatch<'a> { |
| pub _tab: flatbuffers::Table<'a>, |
| } |
| |
| impl<'a> flatbuffers::Follow<'a> for DictionaryBatch<'a> { |
| type Inner = DictionaryBatch<'a>; |
| #[inline] |
| fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { |
| Self { |
| _tab: flatbuffers::Table { buf, loc }, |
| } |
| } |
| } |
| |
| impl<'a> DictionaryBatch<'a> { |
| #[inline] |
| pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { |
| DictionaryBatch { _tab: table } |
| } |
| #[allow(unused_mut)] |
| pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( |
| _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, |
| args: &'args DictionaryBatchArgs<'args>, |
| ) -> flatbuffers::WIPOffset<DictionaryBatch<'bldr>> { |
| let mut builder = DictionaryBatchBuilder::new(_fbb); |
| builder.add_id(args.id); |
| if let Some(x) = args.data { |
| builder.add_data(x); |
| } |
| builder.add_isDelta(args.isDelta); |
| builder.finish() |
| } |
| |
| pub const VT_ID: flatbuffers::VOffsetT = 4; |
| pub const VT_DATA: flatbuffers::VOffsetT = 6; |
| pub const VT_ISDELTA: flatbuffers::VOffsetT = 8; |
| |
| #[inline] |
| pub fn id(&self) -> i64 { |
| self._tab |
| .get::<i64>(DictionaryBatch::VT_ID, Some(0)) |
| .unwrap() |
| } |
| #[inline] |
| pub fn data(&self) -> Option<RecordBatch<'a>> { |
| self._tab.get::<flatbuffers::ForwardsUOffset<RecordBatch>>( |
| DictionaryBatch::VT_DATA, |
| None, |
| ) |
| } |
| /// If isDelta is true the values in the dictionary are to be appended to a |
| /// dictionary with the indicated id. If isDelta is false this dictionary |
| /// should replace the existing dictionary. |
| #[inline] |
| pub fn isDelta(&self) -> bool { |
| self._tab |
| .get::<bool>(DictionaryBatch::VT_ISDELTA, Some(false)) |
| .unwrap() |
| } |
| } |
| |
| impl flatbuffers::Verifiable for DictionaryBatch<'_> { |
| #[inline] |
| fn run_verifier( |
| v: &mut flatbuffers::Verifier, |
| pos: usize, |
| ) -> Result<(), flatbuffers::InvalidFlatbuffer> { |
| use flatbuffers::Verifiable; |
| v.visit_table(pos)? |
| .visit_field::<i64>(&"id", Self::VT_ID, false)? |
| .visit_field::<flatbuffers::ForwardsUOffset<RecordBatch>>( |
| &"data", |
| Self::VT_DATA, |
| false, |
| )? |
| .visit_field::<bool>(&"isDelta", Self::VT_ISDELTA, false)? |
| .finish(); |
| Ok(()) |
| } |
| } |
| pub struct DictionaryBatchArgs<'a> { |
| pub id: i64, |
| pub data: Option<flatbuffers::WIPOffset<RecordBatch<'a>>>, |
| pub isDelta: bool, |
| } |
| impl<'a> Default for DictionaryBatchArgs<'a> { |
| #[inline] |
| fn default() -> Self { |
| DictionaryBatchArgs { |
| id: 0, |
| data: None, |
| isDelta: false, |
| } |
| } |
| } |
| pub struct DictionaryBatchBuilder<'a: 'b, 'b> { |
| fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, |
| } |
| impl<'a: 'b, 'b> DictionaryBatchBuilder<'a, 'b> { |
| #[inline] |
| pub fn add_id(&mut self, id: i64) { |
| self.fbb_.push_slot::<i64>(DictionaryBatch::VT_ID, id, 0); |
| } |
| #[inline] |
| pub fn add_data(&mut self, data: flatbuffers::WIPOffset<RecordBatch<'b>>) { |
| self.fbb_ |
| .push_slot_always::<flatbuffers::WIPOffset<RecordBatch>>( |
| DictionaryBatch::VT_DATA, |
| data, |
| ); |
| } |
| #[inline] |
| pub fn add_isDelta(&mut self, isDelta: bool) { |
| self.fbb_ |
| .push_slot::<bool>(DictionaryBatch::VT_ISDELTA, isDelta, false); |
| } |
| #[inline] |
| pub fn new( |
| _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| ) -> DictionaryBatchBuilder<'a, 'b> { |
| let start = _fbb.start_table(); |
| DictionaryBatchBuilder { |
| fbb_: _fbb, |
| start_: start, |
| } |
| } |
| #[inline] |
| pub fn finish(self) -> flatbuffers::WIPOffset<DictionaryBatch<'a>> { |
| let o = self.fbb_.end_table(self.start_); |
| flatbuffers::WIPOffset::new(o.value()) |
| } |
| } |
| |
| impl std::fmt::Debug for DictionaryBatch<'_> { |
| fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| let mut ds = f.debug_struct("DictionaryBatch"); |
| ds.field("id", &self.id()); |
| ds.field("data", &self.data()); |
| ds.field("isDelta", &self.isDelta()); |
| ds.finish() |
| } |
| } |
| pub enum MessageOffset {} |
| #[derive(Copy, Clone, PartialEq)] |
| |
| pub struct Message<'a> { |
| pub _tab: flatbuffers::Table<'a>, |
| } |
| |
| impl<'a> flatbuffers::Follow<'a> for Message<'a> { |
| type Inner = Message<'a>; |
| #[inline] |
| fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { |
| Self { |
| _tab: flatbuffers::Table { buf, loc }, |
| } |
| } |
| } |
| |
| impl<'a> Message<'a> { |
| #[inline] |
| pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { |
| Message { _tab: table } |
| } |
| #[allow(unused_mut)] |
| pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( |
| _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, |
| args: &'args MessageArgs<'args>, |
| ) -> flatbuffers::WIPOffset<Message<'bldr>> { |
| let mut builder = MessageBuilder::new(_fbb); |
| builder.add_bodyLength(args.bodyLength); |
| if let Some(x) = args.custom_metadata { |
| builder.add_custom_metadata(x); |
| } |
| if let Some(x) = args.header { |
| builder.add_header(x); |
| } |
| builder.add_version(args.version); |
| builder.add_header_type(args.header_type); |
| builder.finish() |
| } |
| |
| pub const VT_VERSION: flatbuffers::VOffsetT = 4; |
| pub const VT_HEADER_TYPE: flatbuffers::VOffsetT = 6; |
| pub const VT_HEADER: flatbuffers::VOffsetT = 8; |
| pub const VT_BODYLENGTH: flatbuffers::VOffsetT = 10; |
| pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 12; |
| |
| #[inline] |
| pub fn version(&self) -> MetadataVersion { |
| self._tab |
| .get::<MetadataVersion>(Message::VT_VERSION, Some(MetadataVersion::V1)) |
| .unwrap() |
| } |
| #[inline] |
| pub fn header_type(&self) -> MessageHeader { |
| self._tab |
| .get::<MessageHeader>(Message::VT_HEADER_TYPE, Some(MessageHeader::NONE)) |
| .unwrap() |
| } |
| #[inline] |
| pub fn header(&self) -> Option<flatbuffers::Table<'a>> { |
| self._tab |
| .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>( |
| Message::VT_HEADER, |
| None, |
| ) |
| } |
| #[inline] |
| pub fn bodyLength(&self) -> i64 { |
| self._tab |
| .get::<i64>(Message::VT_BODYLENGTH, Some(0)) |
| .unwrap() |
| } |
| #[inline] |
| pub fn custom_metadata( |
| &self, |
| ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>> { |
| self._tab.get::<flatbuffers::ForwardsUOffset< |
| flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue>>, |
| >>(Message::VT_CUSTOM_METADATA, None) |
| } |
| #[inline] |
| #[allow(non_snake_case)] |
| pub fn header_as_schema(&self) -> Option<Schema<'a>> { |
| if self.header_type() == MessageHeader::Schema { |
| self.header().map(Schema::init_from_table) |
| } else { |
| None |
| } |
| } |
| |
| #[inline] |
| #[allow(non_snake_case)] |
| pub fn header_as_dictionary_batch(&self) -> Option<DictionaryBatch<'a>> { |
| if self.header_type() == MessageHeader::DictionaryBatch { |
| self.header().map(DictionaryBatch::init_from_table) |
| } else { |
| None |
| } |
| } |
| |
| #[inline] |
| #[allow(non_snake_case)] |
| pub fn header_as_record_batch(&self) -> Option<RecordBatch<'a>> { |
| if self.header_type() == MessageHeader::RecordBatch { |
| self.header().map(RecordBatch::init_from_table) |
| } else { |
| None |
| } |
| } |
| |
| #[inline] |
| #[allow(non_snake_case)] |
| pub fn header_as_tensor(&self) -> Option<Tensor<'a>> { |
| if self.header_type() == MessageHeader::Tensor { |
| self.header().map(Tensor::init_from_table) |
| } else { |
| None |
| } |
| } |
| |
| #[inline] |
| #[allow(non_snake_case)] |
| pub fn header_as_sparse_tensor(&self) -> Option<SparseTensor<'a>> { |
| if self.header_type() == MessageHeader::SparseTensor { |
| self.header().map(SparseTensor::init_from_table) |
| } else { |
| None |
| } |
| } |
| } |
| |
| impl flatbuffers::Verifiable for Message<'_> { |
| #[inline] |
| fn run_verifier( |
| v: &mut flatbuffers::Verifier, |
| pos: usize, |
| ) -> Result<(), flatbuffers::InvalidFlatbuffer> { |
| use flatbuffers::Verifiable; |
| v.visit_table(pos)? |
| .visit_field::<MetadataVersion>(&"version", Self::VT_VERSION, false)? |
| .visit_union::<MessageHeader, _>(&"header_type", Self::VT_HEADER_TYPE, &"header", Self::VT_HEADER, false, |key, v, pos| { |
| match key { |
| MessageHeader::Schema => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Schema>>("MessageHeader::Schema", pos), |
| MessageHeader::DictionaryBatch => v.verify_union_variant::<flatbuffers::ForwardsUOffset<DictionaryBatch>>("MessageHeader::DictionaryBatch", pos), |
| MessageHeader::RecordBatch => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RecordBatch>>("MessageHeader::RecordBatch", pos), |
| MessageHeader::Tensor => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Tensor>>("MessageHeader::Tensor", pos), |
| MessageHeader::SparseTensor => v.verify_union_variant::<flatbuffers::ForwardsUOffset<SparseTensor>>("MessageHeader::SparseTensor", pos), |
| _ => Ok(()), |
| } |
| })? |
| .visit_field::<i64>(&"bodyLength", Self::VT_BODYLENGTH, false)? |
| .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>>>(&"custom_metadata", Self::VT_CUSTOM_METADATA, false)? |
| .finish(); |
| Ok(()) |
| } |
| } |
| pub struct MessageArgs<'a> { |
| pub version: MetadataVersion, |
| pub header_type: MessageHeader, |
| pub header: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>, |
| pub bodyLength: i64, |
| pub custom_metadata: Option< |
| flatbuffers::WIPOffset< |
| flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>, |
| >, |
| >, |
| } |
| impl<'a> Default for MessageArgs<'a> { |
| #[inline] |
| fn default() -> Self { |
| MessageArgs { |
| version: MetadataVersion::V1, |
| header_type: MessageHeader::NONE, |
| header: None, |
| bodyLength: 0, |
| custom_metadata: None, |
| } |
| } |
| } |
| pub struct MessageBuilder<'a: 'b, 'b> { |
| fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>, |
| } |
| impl<'a: 'b, 'b> MessageBuilder<'a, 'b> { |
| #[inline] |
| pub fn add_version(&mut self, version: MetadataVersion) { |
| self.fbb_.push_slot::<MetadataVersion>( |
| Message::VT_VERSION, |
| version, |
| MetadataVersion::V1, |
| ); |
| } |
| #[inline] |
| pub fn add_header_type(&mut self, header_type: MessageHeader) { |
| self.fbb_.push_slot::<MessageHeader>( |
| Message::VT_HEADER_TYPE, |
| header_type, |
| MessageHeader::NONE, |
| ); |
| } |
| #[inline] |
| pub fn add_header( |
| &mut self, |
| header: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>, |
| ) { |
| self.fbb_ |
| .push_slot_always::<flatbuffers::WIPOffset<_>>(Message::VT_HEADER, header); |
| } |
| #[inline] |
| pub fn add_bodyLength(&mut self, bodyLength: i64) { |
| self.fbb_ |
| .push_slot::<i64>(Message::VT_BODYLENGTH, bodyLength, 0); |
| } |
| #[inline] |
| pub fn add_custom_metadata( |
| &mut self, |
| custom_metadata: flatbuffers::WIPOffset< |
| flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<KeyValue<'b>>>, |
| >, |
| ) { |
| self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>( |
| Message::VT_CUSTOM_METADATA, |
| custom_metadata, |
| ); |
| } |
| #[inline] |
| pub fn new( |
| _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| ) -> MessageBuilder<'a, 'b> { |
| let start = _fbb.start_table(); |
| MessageBuilder { |
| fbb_: _fbb, |
| start_: start, |
| } |
| } |
| #[inline] |
| pub fn finish(self) -> flatbuffers::WIPOffset<Message<'a>> { |
| let o = self.fbb_.end_table(self.start_); |
| flatbuffers::WIPOffset::new(o.value()) |
| } |
| } |
| |
| impl std::fmt::Debug for Message<'_> { |
| fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| let mut ds = f.debug_struct("Message"); |
| ds.field("version", &self.version()); |
| ds.field("header_type", &self.header_type()); |
| match self.header_type() { |
| MessageHeader::Schema => { |
| if let Some(x) = self.header_as_schema() { |
| ds.field("header", &x) |
| } else { |
| ds.field( |
| "header", |
| &"InvalidFlatbuffer: Union discriminant does not match value.", |
| ) |
| } |
| } |
| MessageHeader::DictionaryBatch => { |
| if let Some(x) = self.header_as_dictionary_batch() { |
| ds.field("header", &x) |
| } else { |
| ds.field( |
| "header", |
| &"InvalidFlatbuffer: Union discriminant does not match value.", |
| ) |
| } |
| } |
| MessageHeader::RecordBatch => { |
| if let Some(x) = self.header_as_record_batch() { |
| ds.field("header", &x) |
| } else { |
| ds.field( |
| "header", |
| &"InvalidFlatbuffer: Union discriminant does not match value.", |
| ) |
| } |
| } |
| MessageHeader::Tensor => { |
| if let Some(x) = self.header_as_tensor() { |
| ds.field("header", &x) |
| } else { |
| ds.field( |
| "header", |
| &"InvalidFlatbuffer: Union discriminant does not match value.", |
| ) |
| } |
| } |
| MessageHeader::SparseTensor => { |
| if let Some(x) = self.header_as_sparse_tensor() { |
| ds.field("header", &x) |
| } else { |
| ds.field( |
| "header", |
| &"InvalidFlatbuffer: Union discriminant does not match value.", |
| ) |
| } |
| } |
| _ => { |
| let x: Option<()> = None; |
| ds.field("header", &x) |
| } |
| }; |
| ds.field("bodyLength", &self.bodyLength()); |
| ds.field("custom_metadata", &self.custom_metadata()); |
| ds.finish() |
| } |
| } |
| #[inline] |
| #[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")] |
| pub fn get_root_as_message<'a>(buf: &'a [u8]) -> Message<'a> { |
| unsafe { flatbuffers::root_unchecked::<Message<'a>>(buf) } |
| } |
| |
| #[inline] |
| #[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")] |
| pub fn get_size_prefixed_root_as_message<'a>(buf: &'a [u8]) -> Message<'a> { |
| unsafe { flatbuffers::size_prefixed_root_unchecked::<Message<'a>>(buf) } |
| } |
| |
| #[inline] |
| /// Verifies that a buffer of bytes contains a `Message` |
| /// and returns it. |
| /// Note that verification is still experimental and may not |
| /// catch every error, or be maximally performant. For the |
| /// previous, unchecked, behavior use |
| /// `root_as_message_unchecked`. |
| pub fn root_as_message(buf: &[u8]) -> Result<Message, flatbuffers::InvalidFlatbuffer> { |
| flatbuffers::root::<Message>(buf) |
| } |
| #[inline] |
| /// Verifies that a buffer of bytes contains a size prefixed |
| /// `Message` and returns it. |
| /// Note that verification is still experimental and may not |
| /// catch every error, or be maximally performant. For the |
| /// previous, unchecked, behavior use |
| /// `size_prefixed_root_as_message_unchecked`. |
| pub fn size_prefixed_root_as_message( |
| buf: &[u8], |
| ) -> Result<Message, flatbuffers::InvalidFlatbuffer> { |
| flatbuffers::size_prefixed_root::<Message>(buf) |
| } |
| #[inline] |
| /// Verifies, with the given options, that a buffer of bytes |
| /// contains a `Message` and returns it. |
| /// Note that verification is still experimental and may not |
| /// catch every error, or be maximally performant. For the |
| /// previous, unchecked, behavior use |
| /// `root_as_message_unchecked`. |
| pub fn root_as_message_with_opts<'b, 'o>( |
| opts: &'o flatbuffers::VerifierOptions, |
| buf: &'b [u8], |
| ) -> Result<Message<'b>, flatbuffers::InvalidFlatbuffer> { |
| flatbuffers::root_with_opts::<Message<'b>>(opts, buf) |
| } |
| #[inline] |
| /// Verifies, with the given verifier options, that a buffer of |
| /// bytes contains a size prefixed `Message` and returns |
| /// it. Note that verification is still experimental and may not |
| /// catch every error, or be maximally performant. For the |
| /// previous, unchecked, behavior use |
| /// `root_as_message_unchecked`. |
| pub fn size_prefixed_root_as_message_with_opts<'b, 'o>( |
| opts: &'o flatbuffers::VerifierOptions, |
| buf: &'b [u8], |
| ) -> Result<Message<'b>, flatbuffers::InvalidFlatbuffer> { |
| flatbuffers::size_prefixed_root_with_opts::<Message<'b>>(opts, buf) |
| } |
| #[inline] |
| /// Assumes, without verification, that a buffer of bytes contains a Message and returns it. |
| /// # Safety |
| /// Callers must trust the given bytes do indeed contain a valid `Message`. |
| pub unsafe fn root_as_message_unchecked(buf: &[u8]) -> Message { |
| flatbuffers::root_unchecked::<Message>(buf) |
| } |
| #[inline] |
| /// Assumes, without verification, that a buffer of bytes contains a size prefixed Message and returns it. |
| /// # Safety |
| /// Callers must trust the given bytes do indeed contain a valid size prefixed `Message`. |
| pub unsafe fn size_prefixed_root_as_message_unchecked(buf: &[u8]) -> Message { |
| flatbuffers::size_prefixed_root_unchecked::<Message>(buf) |
| } |
| #[inline] |
| pub fn finish_message_buffer<'a, 'b>( |
| fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| root: flatbuffers::WIPOffset<Message<'a>>, |
| ) { |
| fbb.finish(root, None); |
| } |
| |
| #[inline] |
| pub fn finish_size_prefixed_message_buffer<'a, 'b>( |
| fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, |
| root: flatbuffers::WIPOffset<Message<'a>>, |
| ) { |
| fbb.finish_size_prefixed(root, None); |
| } |
