#![allow(dead_code)]
#![allow(unused_imports)]
use crate::ipc::gen::Schema::*;
use flatbuffers::EndianScalar;
use std::{cmp::Ordering, mem};
pub enum TensorDimOffset {}
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct TensorDim<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for TensorDim<'a> {
type Inner = TensorDim<'a>;
#[inline]
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: flatbuffers::Table { buf: buf, loc: loc },
}
}
}
impl<'a> TensorDim<'a> {
#[inline]
pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
TensorDim { _tab: table }
}
#[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TensorDimArgs<'args>,
) -> flatbuffers::WIPOffset<TensorDim<'bldr>> {
let mut builder = TensorDimBuilder::new(_fbb);
builder.add_size_(args.size_);
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
pub const VT_SIZE_: flatbuffers::VOffsetT = 4;
pub const VT_NAME: flatbuffers::VOffsetT = 6;
#[inline]
pub fn size_(&self) -> i64 {
self._tab.get::<i64>(TensorDim::VT_SIZE_, Some(0)).unwrap()
}
#[inline]
pub fn name(&self) -> Option<&'a str> {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(TensorDim::VT_NAME, None)
}
}
pub struct TensorDimArgs<'a> {
pub size_: i64,
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for TensorDimArgs<'a> {
#[inline]
fn default() -> Self {
TensorDimArgs {
size_: 0,
name: None,
}
}
}
pub struct TensorDimBuilder<'a: 'b, 'b> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b> TensorDimBuilder<'a, 'b> {
#[inline]
pub fn add_size_(&mut self, size_: i64) {
self.fbb_.push_slot::<i64>(TensorDim::VT_SIZE_, size_, 0);
}
#[inline]
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(TensorDim::VT_NAME, name);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
) -> TensorDimBuilder<'a, 'b> {
let start = _fbb.start_table();
TensorDimBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<TensorDim<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
pub enum TensorOffset {}
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Tensor<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for Tensor<'a> {
type Inner = Tensor<'a>;
#[inline]
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: flatbuffers::Table { buf: buf, loc: loc },
}
}
}
impl<'a> Tensor<'a> {
#[inline]
pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
Tensor { _tab: table }
}
#[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TensorArgs<'args>,
) -> flatbuffers::WIPOffset<Tensor<'bldr>> {
let mut builder = TensorBuilder::new(_fbb);
if let Some(x) = args.data {
builder.add_data(x);
}
if let Some(x) = args.strides {
builder.add_strides(x);
}
if let Some(x) = args.shape {
builder.add_shape(x);
}
if let Some(x) = args.type_ {
builder.add_type_(x);
}
builder.add_type_type(args.type_type);
builder.finish()
}
pub const VT_TYPE_TYPE: flatbuffers::VOffsetT = 4;
pub const VT_TYPE_: flatbuffers::VOffsetT = 6;
pub const VT_SHAPE: flatbuffers::VOffsetT = 8;
pub const VT_STRIDES: flatbuffers::VOffsetT = 10;
pub const VT_DATA: flatbuffers::VOffsetT = 12;
#[inline]
pub fn type_type(&self) -> Type {
self._tab
.get::<Type>(Tensor::VT_TYPE_TYPE, Some(Type::NONE))
.unwrap()
}
#[inline]
pub fn type_(&self) -> Option<flatbuffers::Table<'a>> {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
Tensor::VT_TYPE_,
None,
)
}
#[inline]
pub fn shape(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim<'a>>>>
{
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<flatbuffers::ForwardsUOffset<TensorDim<'a>>>,
>>(Tensor::VT_SHAPE, None)
}
#[inline]
pub fn strides(&self) -> Option<flatbuffers::Vector<'a, i64>> {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i64>>>(
Tensor::VT_STRIDES,
None,
)
}
#[inline]
pub fn data(&self) -> Option<&'a Buffer> {
self._tab.get::<Buffer>(Tensor::VT_DATA, None)
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_null(&self) -> Option<Null<'a>> {
if self.type_type() == Type::Null {
self.type_().map(|u| Null::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_int(&self) -> Option<Int<'a>> {
if self.type_type() == Type::Int {
self.type_().map(|u| Int::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_floating_point(&self) -> Option<FloatingPoint<'a>> {
if self.type_type() == Type::FloatingPoint {
self.type_().map(|u| FloatingPoint::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_binary(&self) -> Option<Binary<'a>> {
if self.type_type() == Type::Binary {
self.type_().map(|u| Binary::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_utf_8(&self) -> Option<Utf8<'a>> {
if self.type_type() == Type::Utf8 {
self.type_().map(|u| Utf8::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_bool(&self) -> Option<Bool<'a>> {
if self.type_type() == Type::Bool {
self.type_().map(|u| Bool::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_decimal(&self) -> Option<Decimal<'a>> {
if self.type_type() == Type::Decimal {
self.type_().map(|u| Decimal::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_date(&self) -> Option<Date<'a>> {
if self.type_type() == Type::Date {
self.type_().map(|u| Date::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_time(&self) -> Option<Time<'a>> {
if self.type_type() == Type::Time {
self.type_().map(|u| Time::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_timestamp(&self) -> Option<Timestamp<'a>> {
if self.type_type() == Type::Timestamp {
self.type_().map(|u| Timestamp::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_interval(&self) -> Option<Interval<'a>> {
if self.type_type() == Type::Interval {
self.type_().map(|u| Interval::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_list(&self) -> Option<List<'a>> {
if self.type_type() == Type::List {
self.type_().map(|u| List::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_struct_(&self) -> Option<Struct_<'a>> {
if self.type_type() == Type::Struct_ {
self.type_().map(|u| Struct_::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_union(&self) -> Option<Union<'a>> {
if self.type_type() == Type::Union {
self.type_().map(|u| Union::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_fixed_size_binary(&self) -> Option<FixedSizeBinary<'a>> {
if self.type_type() == Type::FixedSizeBinary {
self.type_().map(|u| FixedSizeBinary::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_fixed_size_list(&self) -> Option<FixedSizeList<'a>> {
if self.type_type() == Type::FixedSizeList {
self.type_().map(|u| FixedSizeList::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_map(&self) -> Option<Map<'a>> {
if self.type_type() == Type::Map {
self.type_().map(|u| Map::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_duration(&self) -> Option<Duration<'a>> {
if self.type_type() == Type::Duration {
self.type_().map(|u| Duration::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_large_binary(&self) -> Option<LargeBinary<'a>> {
if self.type_type() == Type::LargeBinary {
self.type_().map(|u| LargeBinary::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_large_utf_8(&self) -> Option<LargeUtf8<'a>> {
if self.type_type() == Type::LargeUtf8 {
self.type_().map(|u| LargeUtf8::init_from_table(u))
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn type_as_large_list(&self) -> Option<LargeList<'a>> {
if self.type_type() == Type::LargeList {
self.type_().map(|u| LargeList::init_from_table(u))
} else {
None
}
}
}
pub struct TensorArgs<'a> {
pub type_type: Type,
pub type_: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
pub shape: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim<'a>>>,
>,
>,
pub strides: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, i64>>>,
pub data: Option<&'a Buffer>,
}
impl<'a> Default for TensorArgs<'a> {
#[inline]
fn default() -> Self {
TensorArgs {
type_type: Type::NONE,
type_: None,
shape: None,
strides: None,
data: None,
}
}
}
pub struct TensorBuilder<'a: 'b, 'b> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b> TensorBuilder<'a, 'b> {
#[inline]
pub fn add_type_type(&mut self, type_type: Type) {
self.fbb_
.push_slot::<Type>(Tensor::VT_TYPE_TYPE, type_type, Type::NONE);
}
#[inline]
pub fn add_type_(
&mut self,
type_: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(Tensor::VT_TYPE_, type_);
}
#[inline]
pub fn add_shape(
&mut self,
shape: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<TensorDim<'b>>>,
>,
) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(Tensor::VT_SHAPE, shape);
}
#[inline]
pub fn add_strides(
&mut self,
strides: flatbuffers::WIPOffset<flatbuffers::Vector<'b, i64>>,
) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(Tensor::VT_STRIDES, strides);
}
#[inline]
pub fn add_data(&mut self, data: &'b Buffer) {
self.fbb_.push_slot_always::<&Buffer>(Tensor::VT_DATA, data);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
) -> TensorBuilder<'a, 'b> {
let start = _fbb.start_table();
TensorBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<Tensor<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
#[inline]
pub fn get_root_as_tensor<'a>(buf: &'a [u8]) -> Tensor<'a> {
flatbuffers::get_root::<Tensor<'a>>(buf)
}
#[inline]
pub fn get_size_prefixed_root_as_tensor<'a>(buf: &'a [u8]) -> Tensor<'a> {
flatbuffers::get_size_prefixed_root::<Tensor<'a>>(buf)
}
#[inline]
pub fn finish_tensor_buffer<'a, 'b>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
root: flatbuffers::WIPOffset<Tensor<'a>>,
) {
fbb.finish(root, None);
}
#[inline]
pub fn finish_size_prefixed_tensor_buffer<'a, 'b>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
root: flatbuffers::WIPOffset<Tensor<'a>>,
) {
fbb.finish_size_prefixed(root, None);
}