extern crate flatbuffers;
#[allow(unused_imports, dead_code)]
pub mod tflite {
use core::cmp::Ordering;
use core::mem;
extern crate flatbuffers;
use self::flatbuffers::{EndianScalar, Follow};
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_ASSOCIATED_FILE_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_ASSOCIATED_FILE_TYPE: i8 = 6;
#[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_ASSOCIATED_FILE_TYPE: [AssociatedFileType; 7] = [
AssociatedFileType::UNKNOWN,
AssociatedFileType::DESCRIPTIONS,
AssociatedFileType::TENSOR_AXIS_LABELS,
AssociatedFileType::TENSOR_VALUE_LABELS,
AssociatedFileType::TENSOR_AXIS_SCORE_CALIBRATION,
AssociatedFileType::VOCABULARY,
AssociatedFileType::SCANN_INDEX_FILE,
];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct AssociatedFileType(pub i8);
#[allow(non_upper_case_globals)]
impl AssociatedFileType {
pub const UNKNOWN: Self = Self(0);
pub const DESCRIPTIONS: Self = Self(1);
pub const TENSOR_AXIS_LABELS: Self = Self(2);
pub const TENSOR_VALUE_LABELS: Self = Self(3);
pub const TENSOR_AXIS_SCORE_CALIBRATION: Self = Self(4);
pub const VOCABULARY: Self = Self(5);
pub const SCANN_INDEX_FILE: Self = Self(6);
pub const ENUM_MIN: i8 = 0;
pub const ENUM_MAX: i8 = 6;
pub const ENUM_VALUES: &'static [Self] = &[
Self::UNKNOWN,
Self::DESCRIPTIONS,
Self::TENSOR_AXIS_LABELS,
Self::TENSOR_VALUE_LABELS,
Self::TENSOR_AXIS_SCORE_CALIBRATION,
Self::VOCABULARY,
Self::SCANN_INDEX_FILE,
];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::UNKNOWN => Some("UNKNOWN"),
Self::DESCRIPTIONS => Some("DESCRIPTIONS"),
Self::TENSOR_AXIS_LABELS => Some("TENSOR_AXIS_LABELS"),
Self::TENSOR_VALUE_LABELS => Some("TENSOR_VALUE_LABELS"),
Self::TENSOR_AXIS_SCORE_CALIBRATION => Some("TENSOR_AXIS_SCORE_CALIBRATION"),
Self::VOCABULARY => Some("VOCABULARY"),
Self::SCANN_INDEX_FILE => Some("SCANN_INDEX_FILE"),
_ => None,
}
}
}
impl core::fmt::Debug for AssociatedFileType {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 AssociatedFileType {
type Inner = Self;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe { flatbuffers::read_scalar_at::<i8>(buf, loc) };
Self(b)
}
}
impl flatbuffers::Push for AssociatedFileType {
type Output = AssociatedFileType;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe {
flatbuffers::emplace_scalar::<i8>(dst, self.0);
}
}
}
impl flatbuffers::EndianScalar for AssociatedFileType {
type Scalar = i8;
#[inline]
fn to_little_endian(self) -> i8 {
self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(v: i8) -> Self {
let b = i8::from_le(v);
Self(b)
}
}
impl<'a> flatbuffers::Verifiable for AssociatedFileType {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
i8::run_verifier(v, pos)
}
}
impl flatbuffers::SimpleToVerifyInSlice for AssociatedFileType {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_COLOR_SPACE_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_COLOR_SPACE_TYPE: i8 = 2;
#[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_COLOR_SPACE_TYPE: [ColorSpaceType; 3] = [
ColorSpaceType::UNKNOWN,
ColorSpaceType::RGB,
ColorSpaceType::GRAYSCALE,
];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ColorSpaceType(pub i8);
#[allow(non_upper_case_globals)]
impl ColorSpaceType {
pub const UNKNOWN: Self = Self(0);
pub const RGB: Self = Self(1);
pub const GRAYSCALE: Self = Self(2);
pub const ENUM_MIN: i8 = 0;
pub const ENUM_MAX: i8 = 2;
pub const ENUM_VALUES: &'static [Self] = &[Self::UNKNOWN, Self::RGB, Self::GRAYSCALE];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::UNKNOWN => Some("UNKNOWN"),
Self::RGB => Some("RGB"),
Self::GRAYSCALE => Some("GRAYSCALE"),
_ => None,
}
}
}
impl core::fmt::Debug for ColorSpaceType {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 ColorSpaceType {
type Inner = Self;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe { flatbuffers::read_scalar_at::<i8>(buf, loc) };
Self(b)
}
}
impl flatbuffers::Push for ColorSpaceType {
type Output = ColorSpaceType;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe {
flatbuffers::emplace_scalar::<i8>(dst, self.0);
}
}
}
impl flatbuffers::EndianScalar for ColorSpaceType {
type Scalar = i8;
#[inline]
fn to_little_endian(self) -> i8 {
self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(v: i8) -> Self {
let b = i8::from_le(v);
Self(b)
}
}
impl<'a> flatbuffers::Verifiable for ColorSpaceType {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
i8::run_verifier(v, pos)
}
}
impl flatbuffers::SimpleToVerifyInSlice for ColorSpaceType {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_BOUNDING_BOX_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_BOUNDING_BOX_TYPE: i8 = 3;
#[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_BOUNDING_BOX_TYPE: [BoundingBoxType; 4] = [
BoundingBoxType::UNKNOWN,
BoundingBoxType::BOUNDARIES,
BoundingBoxType::UPPER_LEFT,
BoundingBoxType::CENTER,
];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct BoundingBoxType(pub i8);
#[allow(non_upper_case_globals)]
impl BoundingBoxType {
pub const UNKNOWN: Self = Self(0);
pub const BOUNDARIES: Self = Self(1);
pub const UPPER_LEFT: Self = Self(2);
pub const CENTER: Self = Self(3);
pub const ENUM_MIN: i8 = 0;
pub const ENUM_MAX: i8 = 3;
pub const ENUM_VALUES: &'static [Self] = &[
Self::UNKNOWN,
Self::BOUNDARIES,
Self::UPPER_LEFT,
Self::CENTER,
];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::UNKNOWN => Some("UNKNOWN"),
Self::BOUNDARIES => Some("BOUNDARIES"),
Self::UPPER_LEFT => Some("UPPER_LEFT"),
Self::CENTER => Some("CENTER"),
_ => None,
}
}
}
impl core::fmt::Debug for BoundingBoxType {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 BoundingBoxType {
type Inner = Self;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe { flatbuffers::read_scalar_at::<i8>(buf, loc) };
Self(b)
}
}
impl flatbuffers::Push for BoundingBoxType {
type Output = BoundingBoxType;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe {
flatbuffers::emplace_scalar::<i8>(dst, self.0);
}
}
}
impl flatbuffers::EndianScalar for BoundingBoxType {
type Scalar = i8;
#[inline]
fn to_little_endian(self) -> i8 {
self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(v: i8) -> Self {
let b = i8::from_le(v);
Self(b)
}
}
impl<'a> flatbuffers::Verifiable for BoundingBoxType {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
i8::run_verifier(v, pos)
}
}
impl flatbuffers::SimpleToVerifyInSlice for BoundingBoxType {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_COORDINATE_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_COORDINATE_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_COORDINATE_TYPE: [CoordinateType; 2] =
[CoordinateType::RATIO, CoordinateType::PIXEL];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct CoordinateType(pub i8);
#[allow(non_upper_case_globals)]
impl CoordinateType {
pub const RATIO: Self = Self(0);
pub const PIXEL: Self = Self(1);
pub const ENUM_MIN: i8 = 0;
pub const ENUM_MAX: i8 = 1;
pub const ENUM_VALUES: &'static [Self] = &[Self::RATIO, Self::PIXEL];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::RATIO => Some("RATIO"),
Self::PIXEL => Some("PIXEL"),
_ => None,
}
}
}
impl core::fmt::Debug for CoordinateType {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 CoordinateType {
type Inner = Self;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe { flatbuffers::read_scalar_at::<i8>(buf, loc) };
Self(b)
}
}
impl flatbuffers::Push for CoordinateType {
type Output = CoordinateType;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe {
flatbuffers::emplace_scalar::<i8>(dst, self.0);
}
}
}
impl flatbuffers::EndianScalar for CoordinateType {
type Scalar = i8;
#[inline]
fn to_little_endian(self) -> i8 {
self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(v: i8) -> Self {
let b = i8::from_le(v);
Self(b)
}
}
impl<'a> flatbuffers::Verifiable for CoordinateType {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
i8::run_verifier(v, pos)
}
}
impl flatbuffers::SimpleToVerifyInSlice for CoordinateType {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_CONTENT_PROPERTIES: u8 = 0;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MAX_CONTENT_PROPERTIES: u8 = 4;
#[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_CONTENT_PROPERTIES: [ContentProperties; 5] = [
ContentProperties::NONE,
ContentProperties::FeatureProperties,
ContentProperties::ImageProperties,
ContentProperties::BoundingBoxProperties,
ContentProperties::AudioProperties,
];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ContentProperties(pub u8);
#[allow(non_upper_case_globals)]
impl ContentProperties {
pub const NONE: Self = Self(0);
pub const FeatureProperties: Self = Self(1);
pub const ImageProperties: Self = Self(2);
pub const BoundingBoxProperties: Self = Self(3);
pub const AudioProperties: Self = Self(4);
pub const ENUM_MIN: u8 = 0;
pub const ENUM_MAX: u8 = 4;
pub const ENUM_VALUES: &'static [Self] = &[
Self::NONE,
Self::FeatureProperties,
Self::ImageProperties,
Self::BoundingBoxProperties,
Self::AudioProperties,
];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::NONE => Some("NONE"),
Self::FeatureProperties => Some("FeatureProperties"),
Self::ImageProperties => Some("ImageProperties"),
Self::BoundingBoxProperties => Some("BoundingBoxProperties"),
Self::AudioProperties => Some("AudioProperties"),
_ => None,
}
}
}
impl core::fmt::Debug for ContentProperties {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 ContentProperties {
type Inner = Self;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe { flatbuffers::read_scalar_at::<u8>(buf, loc) };
Self(b)
}
}
impl flatbuffers::Push for ContentProperties {
type Output = ContentProperties;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe {
flatbuffers::emplace_scalar::<u8>(dst, self.0);
}
}
}
impl flatbuffers::EndianScalar for ContentProperties {
type Scalar = u8;
#[inline]
fn to_little_endian(self) -> u8 {
self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(v: u8) -> Self {
let b = u8::from_le(v);
Self(b)
}
}
impl<'a> flatbuffers::Verifiable for ContentProperties {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
u8::run_verifier(v, pos)
}
}
impl flatbuffers::SimpleToVerifyInSlice for ContentProperties {}
pub struct ContentPropertiesUnionTableOffset {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_SCORE_TRANSFORMATION_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_SCORE_TRANSFORMATION_TYPE: i8 = 2;
#[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_SCORE_TRANSFORMATION_TYPE: [ScoreTransformationType; 3] = [
ScoreTransformationType::IDENTITY,
ScoreTransformationType::LOG,
ScoreTransformationType::INVERSE_LOGISTIC,
];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ScoreTransformationType(pub i8);
#[allow(non_upper_case_globals)]
impl ScoreTransformationType {
pub const IDENTITY: Self = Self(0);
pub const LOG: Self = Self(1);
pub const INVERSE_LOGISTIC: Self = Self(2);
pub const ENUM_MIN: i8 = 0;
pub const ENUM_MAX: i8 = 2;
pub const ENUM_VALUES: &'static [Self] =
&[Self::IDENTITY, Self::LOG, Self::INVERSE_LOGISTIC];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::IDENTITY => Some("IDENTITY"),
Self::LOG => Some("LOG"),
Self::INVERSE_LOGISTIC => Some("INVERSE_LOGISTIC"),
_ => None,
}
}
}
impl core::fmt::Debug for ScoreTransformationType {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 ScoreTransformationType {
type Inner = Self;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe { flatbuffers::read_scalar_at::<i8>(buf, loc) };
Self(b)
}
}
impl flatbuffers::Push for ScoreTransformationType {
type Output = ScoreTransformationType;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe {
flatbuffers::emplace_scalar::<i8>(dst, self.0);
}
}
}
impl flatbuffers::EndianScalar for ScoreTransformationType {
type Scalar = i8;
#[inline]
fn to_little_endian(self) -> i8 {
self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(v: i8) -> Self {
let b = i8::from_le(v);
Self(b)
}
}
impl<'a> flatbuffers::Verifiable for ScoreTransformationType {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
i8::run_verifier(v, pos)
}
}
impl flatbuffers::SimpleToVerifyInSlice for ScoreTransformationType {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_PROCESS_UNIT_OPTIONS: u8 = 0;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MAX_PROCESS_UNIT_OPTIONS: u8 = 6;
#[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_PROCESS_UNIT_OPTIONS: [ProcessUnitOptions; 7] = [
ProcessUnitOptions::NONE,
ProcessUnitOptions::NormalizationOptions,
ProcessUnitOptions::ScoreCalibrationOptions,
ProcessUnitOptions::ScoreThresholdingOptions,
ProcessUnitOptions::BertTokenizerOptions,
ProcessUnitOptions::SentencePieceTokenizerOptions,
ProcessUnitOptions::RegexTokenizerOptions,
];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ProcessUnitOptions(pub u8);
#[allow(non_upper_case_globals)]
impl ProcessUnitOptions {
pub const NONE: Self = Self(0);
pub const NormalizationOptions: Self = Self(1);
pub const ScoreCalibrationOptions: Self = Self(2);
pub const ScoreThresholdingOptions: Self = Self(3);
pub const BertTokenizerOptions: Self = Self(4);
pub const SentencePieceTokenizerOptions: Self = Self(5);
pub const RegexTokenizerOptions: Self = Self(6);
pub const ENUM_MIN: u8 = 0;
pub const ENUM_MAX: u8 = 6;
pub const ENUM_VALUES: &'static [Self] = &[
Self::NONE,
Self::NormalizationOptions,
Self::ScoreCalibrationOptions,
Self::ScoreThresholdingOptions,
Self::BertTokenizerOptions,
Self::SentencePieceTokenizerOptions,
Self::RegexTokenizerOptions,
];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::NONE => Some("NONE"),
Self::NormalizationOptions => Some("NormalizationOptions"),
Self::ScoreCalibrationOptions => Some("ScoreCalibrationOptions"),
Self::ScoreThresholdingOptions => Some("ScoreThresholdingOptions"),
Self::BertTokenizerOptions => Some("BertTokenizerOptions"),
Self::SentencePieceTokenizerOptions => Some("SentencePieceTokenizerOptions"),
Self::RegexTokenizerOptions => Some("RegexTokenizerOptions"),
_ => None,
}
}
}
impl core::fmt::Debug for ProcessUnitOptions {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 ProcessUnitOptions {
type Inner = Self;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe { flatbuffers::read_scalar_at::<u8>(buf, loc) };
Self(b)
}
}
impl flatbuffers::Push for ProcessUnitOptions {
type Output = ProcessUnitOptions;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe {
flatbuffers::emplace_scalar::<u8>(dst, self.0);
}
}
}
impl flatbuffers::EndianScalar for ProcessUnitOptions {
type Scalar = u8;
#[inline]
fn to_little_endian(self) -> u8 {
self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(v: u8) -> Self {
let b = u8::from_le(v);
Self(b)
}
}
impl<'a> flatbuffers::Verifiable for ProcessUnitOptions {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
u8::run_verifier(v, pos)
}
}
impl flatbuffers::SimpleToVerifyInSlice for ProcessUnitOptions {}
pub struct ProcessUnitOptionsUnionTableOffset {}
pub enum AssociatedFileOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct AssociatedFile<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for AssociatedFile<'a> {
type Inner = AssociatedFile<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> AssociatedFile<'a> {
pub const VT_NAME: flatbuffers::VOffsetT = 4;
pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 6;
pub const VT_TYPE_: flatbuffers::VOffsetT = 8;
pub const VT_LOCALE: flatbuffers::VOffsetT = 10;
pub const VT_VERSION: flatbuffers::VOffsetT = 12;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
AssociatedFile { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args AssociatedFileArgs<'args>,
) -> flatbuffers::WIPOffset<AssociatedFile<'bldr>> {
let mut builder = AssociatedFileBuilder::new(_fbb);
if let Some(x) = args.version {
builder.add_version(x);
}
if let Some(x) = args.locale {
builder.add_locale(x);
}
if let Some(x) = args.description {
builder.add_description(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.add_type_(args.type_);
builder.finish()
}
#[inline]
pub fn name(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(AssociatedFile::VT_NAME, None)
}
}
#[inline]
pub fn description(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(AssociatedFile::VT_DESCRIPTION, None)
}
}
#[inline]
pub fn type_(&self) -> AssociatedFileType {
unsafe {
self._tab
.get::<AssociatedFileType>(
AssociatedFile::VT_TYPE_,
Some(AssociatedFileType::UNKNOWN),
)
.unwrap()
}
}
#[inline]
pub fn locale(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(AssociatedFile::VT_LOCALE, None)
}
}
#[inline]
pub fn version(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(AssociatedFile::VT_VERSION, None)
}
}
}
impl flatbuffers::Verifiable for AssociatedFile<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"description",
Self::VT_DESCRIPTION,
false,
)?
.visit_field::<AssociatedFileType>("type_", Self::VT_TYPE_, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"locale",
Self::VT_LOCALE,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"version",
Self::VT_VERSION,
false,
)?
.finish();
Ok(())
}
}
pub struct AssociatedFileArgs<'a> {
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
pub description: Option<flatbuffers::WIPOffset<&'a str>>,
pub type_: AssociatedFileType,
pub locale: Option<flatbuffers::WIPOffset<&'a str>>,
pub version: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for AssociatedFileArgs<'a> {
#[inline]
fn default() -> Self {
AssociatedFileArgs {
name: None,
description: None,
type_: AssociatedFileType::UNKNOWN,
locale: None,
version: None,
}
}
}
pub struct AssociatedFileBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> AssociatedFileBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(AssociatedFile::VT_NAME, name);
}
#[inline]
pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
AssociatedFile::VT_DESCRIPTION,
description,
);
}
#[inline]
pub fn add_type_(&mut self, type_: AssociatedFileType) {
self.fbb_.push_slot::<AssociatedFileType>(
AssociatedFile::VT_TYPE_,
type_,
AssociatedFileType::UNKNOWN,
);
}
#[inline]
pub fn add_locale(&mut self, locale: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(AssociatedFile::VT_LOCALE, locale);
}
#[inline]
pub fn add_version(&mut self, version: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(AssociatedFile::VT_VERSION, version);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> AssociatedFileBuilder<'a, 'b, A> {
let start = _fbb.start_table();
AssociatedFileBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<AssociatedFile<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for AssociatedFile<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("AssociatedFile");
ds.field("name", &self.name());
ds.field("description", &self.description());
ds.field("type_", &self.type_());
ds.field("locale", &self.locale());
ds.field("version", &self.version());
ds.finish()
}
}
pub enum FeaturePropertiesOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct FeatureProperties<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for FeatureProperties<'a> {
type Inner = FeatureProperties<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> FeatureProperties<'a> {
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
FeatureProperties { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
_args: &'args FeaturePropertiesArgs,
) -> flatbuffers::WIPOffset<FeatureProperties<'bldr>> {
let mut builder = FeaturePropertiesBuilder::new(_fbb);
builder.finish()
}
}
impl flatbuffers::Verifiable for FeatureProperties<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?.finish();
Ok(())
}
}
pub struct FeaturePropertiesArgs {}
impl<'a> Default for FeaturePropertiesArgs {
#[inline]
fn default() -> Self {
FeaturePropertiesArgs {}
}
}
pub struct FeaturePropertiesBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> FeaturePropertiesBuilder<'a, 'b, A> {
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> FeaturePropertiesBuilder<'a, 'b, A> {
let start = _fbb.start_table();
FeaturePropertiesBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<FeatureProperties<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for FeatureProperties<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("FeatureProperties");
ds.finish()
}
}
pub enum ImageSizeOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ImageSize<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for ImageSize<'a> {
type Inner = ImageSize<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ImageSize<'a> {
pub const VT_WIDTH: flatbuffers::VOffsetT = 4;
pub const VT_HEIGHT: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
ImageSize { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ImageSizeArgs,
) -> flatbuffers::WIPOffset<ImageSize<'bldr>> {
let mut builder = ImageSizeBuilder::new(_fbb);
builder.add_height(args.height);
builder.add_width(args.width);
builder.finish()
}
#[inline]
pub fn width(&self) -> u32 {
unsafe { self._tab.get::<u32>(ImageSize::VT_WIDTH, Some(0)).unwrap() }
}
#[inline]
pub fn height(&self) -> u32 {
unsafe { self._tab.get::<u32>(ImageSize::VT_HEIGHT, Some(0)).unwrap() }
}
}
impl flatbuffers::Verifiable for ImageSize<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<u32>("width", Self::VT_WIDTH, false)?
.visit_field::<u32>("height", Self::VT_HEIGHT, false)?
.finish();
Ok(())
}
}
pub struct ImageSizeArgs {
pub width: u32,
pub height: u32,
}
impl<'a> Default for ImageSizeArgs {
#[inline]
fn default() -> Self {
ImageSizeArgs {
width: 0,
height: 0,
}
}
}
pub struct ImageSizeBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ImageSizeBuilder<'a, 'b, A> {
#[inline]
pub fn add_width(&mut self, width: u32) {
self.fbb_.push_slot::<u32>(ImageSize::VT_WIDTH, width, 0);
}
#[inline]
pub fn add_height(&mut self, height: u32) {
self.fbb_.push_slot::<u32>(ImageSize::VT_HEIGHT, height, 0);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> ImageSizeBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ImageSizeBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<ImageSize<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for ImageSize<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("ImageSize");
ds.field("width", &self.width());
ds.field("height", &self.height());
ds.finish()
}
}
pub enum ImagePropertiesOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ImageProperties<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for ImageProperties<'a> {
type Inner = ImageProperties<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ImageProperties<'a> {
pub const VT_COLOR_SPACE: flatbuffers::VOffsetT = 4;
pub const VT_DEFAULT_SIZE: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
ImageProperties { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ImagePropertiesArgs<'args>,
) -> flatbuffers::WIPOffset<ImageProperties<'bldr>> {
let mut builder = ImagePropertiesBuilder::new(_fbb);
if let Some(x) = args.default_size {
builder.add_default_size(x);
}
builder.add_color_space(args.color_space);
builder.finish()
}
#[inline]
pub fn color_space(&self) -> ColorSpaceType {
unsafe {
self._tab
.get::<ColorSpaceType>(
ImageProperties::VT_COLOR_SPACE,
Some(ColorSpaceType::UNKNOWN),
)
.unwrap()
}
}
#[inline]
pub fn default_size(&self) -> Option<ImageSize<'a>> {
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<ImageSize>>(
ImageProperties::VT_DEFAULT_SIZE,
None,
)
}
}
}
impl flatbuffers::Verifiable for ImageProperties<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<ColorSpaceType>("color_space", Self::VT_COLOR_SPACE, false)?
.visit_field::<flatbuffers::ForwardsUOffset<ImageSize>>(
"default_size",
Self::VT_DEFAULT_SIZE,
false,
)?
.finish();
Ok(())
}
}
pub struct ImagePropertiesArgs<'a> {
pub color_space: ColorSpaceType,
pub default_size: Option<flatbuffers::WIPOffset<ImageSize<'a>>>,
}
impl<'a> Default for ImagePropertiesArgs<'a> {
#[inline]
fn default() -> Self {
ImagePropertiesArgs {
color_space: ColorSpaceType::UNKNOWN,
default_size: None,
}
}
}
pub struct ImagePropertiesBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ImagePropertiesBuilder<'a, 'b, A> {
#[inline]
pub fn add_color_space(&mut self, color_space: ColorSpaceType) {
self.fbb_.push_slot::<ColorSpaceType>(
ImageProperties::VT_COLOR_SPACE,
color_space,
ColorSpaceType::UNKNOWN,
);
}
#[inline]
pub fn add_default_size(&mut self, default_size: flatbuffers::WIPOffset<ImageSize<'b>>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<ImageSize>>(
ImageProperties::VT_DEFAULT_SIZE,
default_size,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> ImagePropertiesBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ImagePropertiesBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<ImageProperties<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for ImageProperties<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("ImageProperties");
ds.field("color_space", &self.color_space());
ds.field("default_size", &self.default_size());
ds.finish()
}
}
pub enum AudioPropertiesOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct AudioProperties<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for AudioProperties<'a> {
type Inner = AudioProperties<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> AudioProperties<'a> {
pub const VT_SAMPLE_RATE: flatbuffers::VOffsetT = 4;
pub const VT_CHANNELS: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
AudioProperties { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args AudioPropertiesArgs,
) -> flatbuffers::WIPOffset<AudioProperties<'bldr>> {
let mut builder = AudioPropertiesBuilder::new(_fbb);
builder.add_channels(args.channels);
builder.add_sample_rate(args.sample_rate);
builder.finish()
}
#[inline]
pub fn sample_rate(&self) -> u32 {
unsafe {
self._tab
.get::<u32>(AudioProperties::VT_SAMPLE_RATE, Some(0))
.unwrap()
}
}
#[inline]
pub fn channels(&self) -> u32 {
unsafe {
self._tab
.get::<u32>(AudioProperties::VT_CHANNELS, Some(0))
.unwrap()
}
}
}
impl flatbuffers::Verifiable for AudioProperties<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<u32>("sample_rate", Self::VT_SAMPLE_RATE, false)?
.visit_field::<u32>("channels", Self::VT_CHANNELS, false)?
.finish();
Ok(())
}
}
pub struct AudioPropertiesArgs {
pub sample_rate: u32,
pub channels: u32,
}
impl<'a> Default for AudioPropertiesArgs {
#[inline]
fn default() -> Self {
AudioPropertiesArgs {
sample_rate: 0,
channels: 0,
}
}
}
pub struct AudioPropertiesBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> AudioPropertiesBuilder<'a, 'b, A> {
#[inline]
pub fn add_sample_rate(&mut self, sample_rate: u32) {
self.fbb_
.push_slot::<u32>(AudioProperties::VT_SAMPLE_RATE, sample_rate, 0);
}
#[inline]
pub fn add_channels(&mut self, channels: u32) {
self.fbb_
.push_slot::<u32>(AudioProperties::VT_CHANNELS, channels, 0);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> AudioPropertiesBuilder<'a, 'b, A> {
let start = _fbb.start_table();
AudioPropertiesBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<AudioProperties<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for AudioProperties<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("AudioProperties");
ds.field("sample_rate", &self.sample_rate());
ds.field("channels", &self.channels());
ds.finish()
}
}
pub enum BoundingBoxPropertiesOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct BoundingBoxProperties<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for BoundingBoxProperties<'a> {
type Inner = BoundingBoxProperties<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> BoundingBoxProperties<'a> {
pub const VT_INDEX: flatbuffers::VOffsetT = 4;
pub const VT_TYPE_: flatbuffers::VOffsetT = 6;
pub const VT_COORDINATE_TYPE: flatbuffers::VOffsetT = 8;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
BoundingBoxProperties { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args BoundingBoxPropertiesArgs<'args>,
) -> flatbuffers::WIPOffset<BoundingBoxProperties<'bldr>> {
let mut builder = BoundingBoxPropertiesBuilder::new(_fbb);
if let Some(x) = args.index {
builder.add_index(x);
}
builder.add_coordinate_type(args.coordinate_type);
builder.add_type_(args.type_);
builder.finish()
}
#[inline]
pub fn index(&self) -> Option<flatbuffers::Vector<'a, u32>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u32>>>(
BoundingBoxProperties::VT_INDEX,
None,
)
}
}
#[inline]
pub fn type_(&self) -> BoundingBoxType {
unsafe {
self._tab
.get::<BoundingBoxType>(
BoundingBoxProperties::VT_TYPE_,
Some(BoundingBoxType::UNKNOWN),
)
.unwrap()
}
}
#[inline]
pub fn coordinate_type(&self) -> CoordinateType {
unsafe {
self._tab
.get::<CoordinateType>(
BoundingBoxProperties::VT_COORDINATE_TYPE,
Some(CoordinateType::RATIO),
)
.unwrap()
}
}
}
impl flatbuffers::Verifiable for BoundingBoxProperties<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u32>>>(
"index",
Self::VT_INDEX,
false,
)?
.visit_field::<BoundingBoxType>("type_", Self::VT_TYPE_, false)?
.visit_field::<CoordinateType>("coordinate_type", Self::VT_COORDINATE_TYPE, false)?
.finish();
Ok(())
}
}
pub struct BoundingBoxPropertiesArgs<'a> {
pub index: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u32>>>,
pub type_: BoundingBoxType,
pub coordinate_type: CoordinateType,
}
impl<'a> Default for BoundingBoxPropertiesArgs<'a> {
#[inline]
fn default() -> Self {
BoundingBoxPropertiesArgs {
index: None,
type_: BoundingBoxType::UNKNOWN,
coordinate_type: CoordinateType::RATIO,
}
}
}
pub struct BoundingBoxPropertiesBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> BoundingBoxPropertiesBuilder<'a, 'b, A> {
#[inline]
pub fn add_index(&mut self, index: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u32>>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
BoundingBoxProperties::VT_INDEX,
index,
);
}
#[inline]
pub fn add_type_(&mut self, type_: BoundingBoxType) {
self.fbb_.push_slot::<BoundingBoxType>(
BoundingBoxProperties::VT_TYPE_,
type_,
BoundingBoxType::UNKNOWN,
);
}
#[inline]
pub fn add_coordinate_type(&mut self, coordinate_type: CoordinateType) {
self.fbb_.push_slot::<CoordinateType>(
BoundingBoxProperties::VT_COORDINATE_TYPE,
coordinate_type,
CoordinateType::RATIO,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> BoundingBoxPropertiesBuilder<'a, 'b, A> {
let start = _fbb.start_table();
BoundingBoxPropertiesBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<BoundingBoxProperties<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for BoundingBoxProperties<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("BoundingBoxProperties");
ds.field("index", &self.index());
ds.field("type_", &self.type_());
ds.field("coordinate_type", &self.coordinate_type());
ds.finish()
}
}
pub enum ValueRangeOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ValueRange<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for ValueRange<'a> {
type Inner = ValueRange<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ValueRange<'a> {
pub const VT_MIN: flatbuffers::VOffsetT = 4;
pub const VT_MAX: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
ValueRange { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ValueRangeArgs,
) -> flatbuffers::WIPOffset<ValueRange<'bldr>> {
let mut builder = ValueRangeBuilder::new(_fbb);
builder.add_max(args.max);
builder.add_min(args.min);
builder.finish()
}
#[inline]
pub fn min(&self) -> i32 {
unsafe { self._tab.get::<i32>(ValueRange::VT_MIN, Some(0)).unwrap() }
}
#[inline]
pub fn max(&self) -> i32 {
unsafe { self._tab.get::<i32>(ValueRange::VT_MAX, Some(0)).unwrap() }
}
}
impl flatbuffers::Verifiable for ValueRange<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<i32>("min", Self::VT_MIN, false)?
.visit_field::<i32>("max", Self::VT_MAX, false)?
.finish();
Ok(())
}
}
pub struct ValueRangeArgs {
pub min: i32,
pub max: i32,
}
impl<'a> Default for ValueRangeArgs {
#[inline]
fn default() -> Self {
ValueRangeArgs { min: 0, max: 0 }
}
}
pub struct ValueRangeBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ValueRangeBuilder<'a, 'b, A> {
#[inline]
pub fn add_min(&mut self, min: i32) {
self.fbb_.push_slot::<i32>(ValueRange::VT_MIN, min, 0);
}
#[inline]
pub fn add_max(&mut self, max: i32) {
self.fbb_.push_slot::<i32>(ValueRange::VT_MAX, max, 0);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> ValueRangeBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ValueRangeBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<ValueRange<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for ValueRange<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("ValueRange");
ds.field("min", &self.min());
ds.field("max", &self.max());
ds.finish()
}
}
pub enum ContentOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Content<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for Content<'a> {
type Inner = Content<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> Content<'a> {
pub const VT_CONTENT_PROPERTIES_TYPE: flatbuffers::VOffsetT = 4;
pub const VT_CONTENT_PROPERTIES: flatbuffers::VOffsetT = 6;
pub const VT_RANGE: flatbuffers::VOffsetT = 8;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
Content { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ContentArgs<'args>,
) -> flatbuffers::WIPOffset<Content<'bldr>> {
let mut builder = ContentBuilder::new(_fbb);
if let Some(x) = args.range {
builder.add_range(x);
}
if let Some(x) = args.content_properties {
builder.add_content_properties(x);
}
builder.add_content_properties_type(args.content_properties_type);
builder.finish()
}
#[inline]
pub fn content_properties_type(&self) -> ContentProperties {
unsafe {
self._tab
.get::<ContentProperties>(
Content::VT_CONTENT_PROPERTIES_TYPE,
Some(ContentProperties::NONE),
)
.unwrap()
}
}
#[inline]
pub fn content_properties(&self) -> Option<flatbuffers::Table<'a>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
Content::VT_CONTENT_PROPERTIES,
None,
)
}
}
#[inline]
pub fn range(&self) -> Option<ValueRange<'a>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<ValueRange>>(Content::VT_RANGE, None)
}
}
#[inline]
#[allow(non_snake_case)]
pub fn content_properties_as_feature_properties(&self) -> Option<FeatureProperties<'a>> {
if self.content_properties_type() == ContentProperties::FeatureProperties {
self.content_properties().map(|t| {
unsafe { FeatureProperties::init_from_table(t) }
})
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn content_properties_as_image_properties(&self) -> Option<ImageProperties<'a>> {
if self.content_properties_type() == ContentProperties::ImageProperties {
self.content_properties().map(|t| {
unsafe { ImageProperties::init_from_table(t) }
})
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn content_properties_as_bounding_box_properties(
&self,
) -> Option<BoundingBoxProperties<'a>> {
if self.content_properties_type() == ContentProperties::BoundingBoxProperties {
self.content_properties().map(|t| {
unsafe { BoundingBoxProperties::init_from_table(t) }
})
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn content_properties_as_audio_properties(&self) -> Option<AudioProperties<'a>> {
if self.content_properties_type() == ContentProperties::AudioProperties {
self.content_properties().map(|t| {
unsafe { AudioProperties::init_from_table(t) }
})
} else {
None
}
}
}
impl flatbuffers::Verifiable for Content<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_union::<ContentProperties, _>("content_properties_type", Self::VT_CONTENT_PROPERTIES_TYPE, "content_properties", Self::VT_CONTENT_PROPERTIES, false, |key, v, pos| {
match key {
ContentProperties::FeatureProperties => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FeatureProperties>>("ContentProperties::FeatureProperties", pos),
ContentProperties::ImageProperties => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ImageProperties>>("ContentProperties::ImageProperties", pos),
ContentProperties::BoundingBoxProperties => v.verify_union_variant::<flatbuffers::ForwardsUOffset<BoundingBoxProperties>>("ContentProperties::BoundingBoxProperties", pos),
ContentProperties::AudioProperties => v.verify_union_variant::<flatbuffers::ForwardsUOffset<AudioProperties>>("ContentProperties::AudioProperties", pos),
_ => Ok(()),
}
})?
.visit_field::<flatbuffers::ForwardsUOffset<ValueRange>>("range", Self::VT_RANGE, false)?
.finish();
Ok(())
}
}
pub struct ContentArgs<'a> {
pub content_properties_type: ContentProperties,
pub content_properties: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
pub range: Option<flatbuffers::WIPOffset<ValueRange<'a>>>,
}
impl<'a> Default for ContentArgs<'a> {
#[inline]
fn default() -> Self {
ContentArgs {
content_properties_type: ContentProperties::NONE,
content_properties: None,
range: None,
}
}
}
pub struct ContentBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ContentBuilder<'a, 'b, A> {
#[inline]
pub fn add_content_properties_type(&mut self, content_properties_type: ContentProperties) {
self.fbb_.push_slot::<ContentProperties>(
Content::VT_CONTENT_PROPERTIES_TYPE,
content_properties_type,
ContentProperties::NONE,
);
}
#[inline]
pub fn add_content_properties(
&mut self,
content_properties: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
Content::VT_CONTENT_PROPERTIES,
content_properties,
);
}
#[inline]
pub fn add_range(&mut self, range: flatbuffers::WIPOffset<ValueRange<'b>>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<ValueRange>>(Content::VT_RANGE, range);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> ContentBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ContentBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<Content<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for Content<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("Content");
ds.field("content_properties_type", &self.content_properties_type());
match self.content_properties_type() {
ContentProperties::FeatureProperties => {
if let Some(x) = self.content_properties_as_feature_properties() {
ds.field("content_properties", &x)
} else {
ds.field(
"content_properties",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
ContentProperties::ImageProperties => {
if let Some(x) = self.content_properties_as_image_properties() {
ds.field("content_properties", &x)
} else {
ds.field(
"content_properties",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
ContentProperties::BoundingBoxProperties => {
if let Some(x) = self.content_properties_as_bounding_box_properties() {
ds.field("content_properties", &x)
} else {
ds.field(
"content_properties",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
ContentProperties::AudioProperties => {
if let Some(x) = self.content_properties_as_audio_properties() {
ds.field("content_properties", &x)
} else {
ds.field(
"content_properties",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
_ => {
let x: Option<()> = None;
ds.field("content_properties", &x)
}
};
ds.field("range", &self.range());
ds.finish()
}
}
pub enum NormalizationOptionsOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct NormalizationOptions<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for NormalizationOptions<'a> {
type Inner = NormalizationOptions<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> NormalizationOptions<'a> {
pub const VT_MEAN: flatbuffers::VOffsetT = 4;
pub const VT_STD_: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
NormalizationOptions { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args NormalizationOptionsArgs<'args>,
) -> flatbuffers::WIPOffset<NormalizationOptions<'bldr>> {
let mut builder = NormalizationOptionsBuilder::new(_fbb);
if let Some(x) = args.std_ {
builder.add_std_(x);
}
if let Some(x) = args.mean {
builder.add_mean(x);
}
builder.finish()
}
#[inline]
pub fn mean(&self) -> Option<flatbuffers::Vector<'a, f32>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, f32>>>(
NormalizationOptions::VT_MEAN,
None,
)
}
}
#[inline]
pub fn std_(&self) -> Option<flatbuffers::Vector<'a, f32>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, f32>>>(
NormalizationOptions::VT_STD_,
None,
)
}
}
}
impl flatbuffers::Verifiable for NormalizationOptions<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f32>>>(
"mean",
Self::VT_MEAN,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f32>>>(
"std_",
Self::VT_STD_,
false,
)?
.finish();
Ok(())
}
}
pub struct NormalizationOptionsArgs<'a> {
pub mean: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f32>>>,
pub std_: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f32>>>,
}
impl<'a> Default for NormalizationOptionsArgs<'a> {
#[inline]
fn default() -> Self {
NormalizationOptionsArgs {
mean: None,
std_: None,
}
}
}
pub struct NormalizationOptionsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> NormalizationOptionsBuilder<'a, 'b, A> {
#[inline]
pub fn add_mean(&mut self, mean: flatbuffers::WIPOffset<flatbuffers::Vector<'b, f32>>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(NormalizationOptions::VT_MEAN, mean);
}
#[inline]
pub fn add_std_(&mut self, std_: flatbuffers::WIPOffset<flatbuffers::Vector<'b, f32>>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(NormalizationOptions::VT_STD_, std_);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> NormalizationOptionsBuilder<'a, 'b, A> {
let start = _fbb.start_table();
NormalizationOptionsBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<NormalizationOptions<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for NormalizationOptions<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("NormalizationOptions");
ds.field("mean", &self.mean());
ds.field("std_", &self.std_());
ds.finish()
}
}
pub enum ScoreCalibrationOptionsOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ScoreCalibrationOptions<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for ScoreCalibrationOptions<'a> {
type Inner = ScoreCalibrationOptions<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ScoreCalibrationOptions<'a> {
pub const VT_SCORE_TRANSFORMATION: flatbuffers::VOffsetT = 4;
pub const VT_DEFAULT_SCORE: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
ScoreCalibrationOptions { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ScoreCalibrationOptionsArgs,
) -> flatbuffers::WIPOffset<ScoreCalibrationOptions<'bldr>> {
let mut builder = ScoreCalibrationOptionsBuilder::new(_fbb);
builder.add_default_score(args.default_score);
builder.add_score_transformation(args.score_transformation);
builder.finish()
}
#[inline]
pub fn score_transformation(&self) -> ScoreTransformationType {
unsafe {
self._tab
.get::<ScoreTransformationType>(
ScoreCalibrationOptions::VT_SCORE_TRANSFORMATION,
Some(ScoreTransformationType::IDENTITY),
)
.unwrap()
}
}
#[inline]
pub fn default_score(&self) -> f32 {
unsafe {
self._tab
.get::<f32>(ScoreCalibrationOptions::VT_DEFAULT_SCORE, Some(0.0))
.unwrap()
}
}
}
impl flatbuffers::Verifiable for ScoreCalibrationOptions<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<ScoreTransformationType>(
"score_transformation",
Self::VT_SCORE_TRANSFORMATION,
false,
)?
.visit_field::<f32>("default_score", Self::VT_DEFAULT_SCORE, false)?
.finish();
Ok(())
}
}
pub struct ScoreCalibrationOptionsArgs {
pub score_transformation: ScoreTransformationType,
pub default_score: f32,
}
impl<'a> Default for ScoreCalibrationOptionsArgs {
#[inline]
fn default() -> Self {
ScoreCalibrationOptionsArgs {
score_transformation: ScoreTransformationType::IDENTITY,
default_score: 0.0,
}
}
}
pub struct ScoreCalibrationOptionsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ScoreCalibrationOptionsBuilder<'a, 'b, A> {
#[inline]
pub fn add_score_transformation(&mut self, score_transformation: ScoreTransformationType) {
self.fbb_.push_slot::<ScoreTransformationType>(
ScoreCalibrationOptions::VT_SCORE_TRANSFORMATION,
score_transformation,
ScoreTransformationType::IDENTITY,
);
}
#[inline]
pub fn add_default_score(&mut self, default_score: f32) {
self.fbb_.push_slot::<f32>(
ScoreCalibrationOptions::VT_DEFAULT_SCORE,
default_score,
0.0,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> ScoreCalibrationOptionsBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ScoreCalibrationOptionsBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<ScoreCalibrationOptions<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for ScoreCalibrationOptions<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("ScoreCalibrationOptions");
ds.field("score_transformation", &self.score_transformation());
ds.field("default_score", &self.default_score());
ds.finish()
}
}
pub enum ScoreThresholdingOptionsOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ScoreThresholdingOptions<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for ScoreThresholdingOptions<'a> {
type Inner = ScoreThresholdingOptions<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ScoreThresholdingOptions<'a> {
pub const VT_GLOBAL_SCORE_THRESHOLD: flatbuffers::VOffsetT = 4;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
ScoreThresholdingOptions { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ScoreThresholdingOptionsArgs,
) -> flatbuffers::WIPOffset<ScoreThresholdingOptions<'bldr>> {
let mut builder = ScoreThresholdingOptionsBuilder::new(_fbb);
builder.add_global_score_threshold(args.global_score_threshold);
builder.finish()
}
#[inline]
pub fn global_score_threshold(&self) -> f32 {
unsafe {
self._tab
.get::<f32>(
ScoreThresholdingOptions::VT_GLOBAL_SCORE_THRESHOLD,
Some(0.0),
)
.unwrap()
}
}
}
impl flatbuffers::Verifiable for ScoreThresholdingOptions<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<f32>(
"global_score_threshold",
Self::VT_GLOBAL_SCORE_THRESHOLD,
false,
)?
.finish();
Ok(())
}
}
pub struct ScoreThresholdingOptionsArgs {
pub global_score_threshold: f32,
}
impl<'a> Default for ScoreThresholdingOptionsArgs {
#[inline]
fn default() -> Self {
ScoreThresholdingOptionsArgs {
global_score_threshold: 0.0,
}
}
}
pub struct ScoreThresholdingOptionsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ScoreThresholdingOptionsBuilder<'a, 'b, A> {
#[inline]
pub fn add_global_score_threshold(&mut self, global_score_threshold: f32) {
self.fbb_.push_slot::<f32>(
ScoreThresholdingOptions::VT_GLOBAL_SCORE_THRESHOLD,
global_score_threshold,
0.0,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> ScoreThresholdingOptionsBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ScoreThresholdingOptionsBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<ScoreThresholdingOptions<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for ScoreThresholdingOptions<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("ScoreThresholdingOptions");
ds.field("global_score_threshold", &self.global_score_threshold());
ds.finish()
}
}
pub enum BertTokenizerOptionsOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct BertTokenizerOptions<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for BertTokenizerOptions<'a> {
type Inner = BertTokenizerOptions<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> BertTokenizerOptions<'a> {
pub const VT_VOCAB_FILE: flatbuffers::VOffsetT = 4;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
BertTokenizerOptions { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args BertTokenizerOptionsArgs<'args>,
) -> flatbuffers::WIPOffset<BertTokenizerOptions<'bldr>> {
let mut builder = BertTokenizerOptionsBuilder::new(_fbb);
if let Some(x) = args.vocab_file {
builder.add_vocab_file(x);
}
builder.finish()
}
#[inline]
pub fn vocab_file(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>(BertTokenizerOptions::VT_VOCAB_FILE, None)
}
}
}
impl flatbuffers::Verifiable for BertTokenizerOptions<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>("vocab_file", Self::VT_VOCAB_FILE, false)?
.finish();
Ok(())
}
}
pub struct BertTokenizerOptionsArgs<'a> {
pub vocab_file: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>,
>,
>,
}
impl<'a> Default for BertTokenizerOptionsArgs<'a> {
#[inline]
fn default() -> Self {
BertTokenizerOptionsArgs { vocab_file: None }
}
}
pub struct BertTokenizerOptionsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> BertTokenizerOptionsBuilder<'a, 'b, A> {
#[inline]
pub fn add_vocab_file(
&mut self,
vocab_file: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<AssociatedFile<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
BertTokenizerOptions::VT_VOCAB_FILE,
vocab_file,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> BertTokenizerOptionsBuilder<'a, 'b, A> {
let start = _fbb.start_table();
BertTokenizerOptionsBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<BertTokenizerOptions<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for BertTokenizerOptions<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("BertTokenizerOptions");
ds.field("vocab_file", &self.vocab_file());
ds.finish()
}
}
pub enum SentencePieceTokenizerOptionsOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct SentencePieceTokenizerOptions<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for SentencePieceTokenizerOptions<'a> {
type Inner = SentencePieceTokenizerOptions<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> SentencePieceTokenizerOptions<'a> {
pub const VT_SENTENCEPIECE_MODEL: flatbuffers::VOffsetT = 4;
pub const VT_VOCAB_FILE: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
SentencePieceTokenizerOptions { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args SentencePieceTokenizerOptionsArgs<'args>,
) -> flatbuffers::WIPOffset<SentencePieceTokenizerOptions<'bldr>> {
let mut builder = SentencePieceTokenizerOptionsBuilder::new(_fbb);
if let Some(x) = args.vocab_file {
builder.add_vocab_file(x);
}
if let Some(x) = args.sentencePiece_model {
builder.add_sentencePiece_model(x);
}
builder.finish()
}
#[inline]
pub fn sentencePiece_model(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>(
SentencePieceTokenizerOptions::VT_SENTENCEPIECE_MODEL, None
)
}
}
#[inline]
pub fn vocab_file(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>(SentencePieceTokenizerOptions::VT_VOCAB_FILE, None)
}
}
}
impl flatbuffers::Verifiable for SentencePieceTokenizerOptions<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>("sentencePiece_model", Self::VT_SENTENCEPIECE_MODEL, false)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>("vocab_file", Self::VT_VOCAB_FILE, false)?
.finish();
Ok(())
}
}
pub struct SentencePieceTokenizerOptionsArgs<'a> {
pub sentencePiece_model: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>,
>,
>,
pub vocab_file: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>,
>,
>,
}
impl<'a> Default for SentencePieceTokenizerOptionsArgs<'a> {
#[inline]
fn default() -> Self {
SentencePieceTokenizerOptionsArgs {
sentencePiece_model: None,
vocab_file: None,
}
}
}
pub struct SentencePieceTokenizerOptionsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> SentencePieceTokenizerOptionsBuilder<'a, 'b, A> {
#[inline]
pub fn add_sentencePiece_model(
&mut self,
sentencePiece_model: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<AssociatedFile<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SentencePieceTokenizerOptions::VT_SENTENCEPIECE_MODEL,
sentencePiece_model,
);
}
#[inline]
pub fn add_vocab_file(
&mut self,
vocab_file: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<AssociatedFile<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SentencePieceTokenizerOptions::VT_VOCAB_FILE,
vocab_file,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> SentencePieceTokenizerOptionsBuilder<'a, 'b, A> {
let start = _fbb.start_table();
SentencePieceTokenizerOptionsBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<SentencePieceTokenizerOptions<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for SentencePieceTokenizerOptions<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("SentencePieceTokenizerOptions");
ds.field("sentencePiece_model", &self.sentencePiece_model());
ds.field("vocab_file", &self.vocab_file());
ds.finish()
}
}
pub enum RegexTokenizerOptionsOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct RegexTokenizerOptions<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for RegexTokenizerOptions<'a> {
type Inner = RegexTokenizerOptions<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> RegexTokenizerOptions<'a> {
pub const VT_DELIM_REGEX_PATTERN: flatbuffers::VOffsetT = 4;
pub const VT_VOCAB_FILE: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
RegexTokenizerOptions { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args RegexTokenizerOptionsArgs<'args>,
) -> flatbuffers::WIPOffset<RegexTokenizerOptions<'bldr>> {
let mut builder = RegexTokenizerOptionsBuilder::new(_fbb);
if let Some(x) = args.vocab_file {
builder.add_vocab_file(x);
}
if let Some(x) = args.delim_regex_pattern {
builder.add_delim_regex_pattern(x);
}
builder.finish()
}
#[inline]
pub fn delim_regex_pattern(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(
RegexTokenizerOptions::VT_DELIM_REGEX_PATTERN,
None,
)
}
}
#[inline]
pub fn vocab_file(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>(RegexTokenizerOptions::VT_VOCAB_FILE, None)
}
}
}
impl flatbuffers::Verifiable for RegexTokenizerOptions<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"delim_regex_pattern",
Self::VT_DELIM_REGEX_PATTERN,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>("vocab_file", Self::VT_VOCAB_FILE, false)?
.finish();
Ok(())
}
}
pub struct RegexTokenizerOptionsArgs<'a> {
pub delim_regex_pattern: Option<flatbuffers::WIPOffset<&'a str>>,
pub vocab_file: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>,
>,
>,
}
impl<'a> Default for RegexTokenizerOptionsArgs<'a> {
#[inline]
fn default() -> Self {
RegexTokenizerOptionsArgs {
delim_regex_pattern: None,
vocab_file: None,
}
}
}
pub struct RegexTokenizerOptionsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> RegexTokenizerOptionsBuilder<'a, 'b, A> {
#[inline]
pub fn add_delim_regex_pattern(
&mut self,
delim_regex_pattern: flatbuffers::WIPOffset<&'b str>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
RegexTokenizerOptions::VT_DELIM_REGEX_PATTERN,
delim_regex_pattern,
);
}
#[inline]
pub fn add_vocab_file(
&mut self,
vocab_file: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<AssociatedFile<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
RegexTokenizerOptions::VT_VOCAB_FILE,
vocab_file,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> RegexTokenizerOptionsBuilder<'a, 'b, A> {
let start = _fbb.start_table();
RegexTokenizerOptionsBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<RegexTokenizerOptions<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for RegexTokenizerOptions<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("RegexTokenizerOptions");
ds.field("delim_regex_pattern", &self.delim_regex_pattern());
ds.field("vocab_file", &self.vocab_file());
ds.finish()
}
}
pub enum ProcessUnitOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ProcessUnit<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for ProcessUnit<'a> {
type Inner = ProcessUnit<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ProcessUnit<'a> {
pub const VT_OPTIONS_TYPE: flatbuffers::VOffsetT = 4;
pub const VT_OPTIONS: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
ProcessUnit { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ProcessUnitArgs,
) -> flatbuffers::WIPOffset<ProcessUnit<'bldr>> {
let mut builder = ProcessUnitBuilder::new(_fbb);
if let Some(x) = args.options {
builder.add_options(x);
}
builder.add_options_type(args.options_type);
builder.finish()
}
#[inline]
pub fn options_type(&self) -> ProcessUnitOptions {
unsafe {
self._tab
.get::<ProcessUnitOptions>(
ProcessUnit::VT_OPTIONS_TYPE,
Some(ProcessUnitOptions::NONE),
)
.unwrap()
}
}
#[inline]
pub fn options(&self) -> Option<flatbuffers::Table<'a>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
ProcessUnit::VT_OPTIONS,
None,
)
}
}
#[inline]
#[allow(non_snake_case)]
pub fn options_as_normalization_options(&self) -> Option<NormalizationOptions<'a>> {
if self.options_type() == ProcessUnitOptions::NormalizationOptions {
self.options().map(|t| {
unsafe { NormalizationOptions::init_from_table(t) }
})
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn options_as_score_calibration_options(&self) -> Option<ScoreCalibrationOptions<'a>> {
if self.options_type() == ProcessUnitOptions::ScoreCalibrationOptions {
self.options().map(|t| {
unsafe { ScoreCalibrationOptions::init_from_table(t) }
})
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn options_as_score_thresholding_options(
&self,
) -> Option<ScoreThresholdingOptions<'a>> {
if self.options_type() == ProcessUnitOptions::ScoreThresholdingOptions {
self.options().map(|t| {
unsafe { ScoreThresholdingOptions::init_from_table(t) }
})
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn options_as_bert_tokenizer_options(&self) -> Option<BertTokenizerOptions<'a>> {
if self.options_type() == ProcessUnitOptions::BertTokenizerOptions {
self.options().map(|t| {
unsafe { BertTokenizerOptions::init_from_table(t) }
})
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn options_as_sentence_piece_tokenizer_options(
&self,
) -> Option<SentencePieceTokenizerOptions<'a>> {
if self.options_type() == ProcessUnitOptions::SentencePieceTokenizerOptions {
self.options().map(|t| {
unsafe { SentencePieceTokenizerOptions::init_from_table(t) }
})
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn options_as_regex_tokenizer_options(&self) -> Option<RegexTokenizerOptions<'a>> {
if self.options_type() == ProcessUnitOptions::RegexTokenizerOptions {
self.options().map(|t| {
unsafe { RegexTokenizerOptions::init_from_table(t) }
})
} else {
None
}
}
}
impl flatbuffers::Verifiable for ProcessUnit<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_union::<ProcessUnitOptions, _>("options_type", Self::VT_OPTIONS_TYPE, "options", Self::VT_OPTIONS, false, |key, v, pos| {
match key {
ProcessUnitOptions::NormalizationOptions => v.verify_union_variant::<flatbuffers::ForwardsUOffset<NormalizationOptions>>("ProcessUnitOptions::NormalizationOptions", pos),
ProcessUnitOptions::ScoreCalibrationOptions => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ScoreCalibrationOptions>>("ProcessUnitOptions::ScoreCalibrationOptions", pos),
ProcessUnitOptions::ScoreThresholdingOptions => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ScoreThresholdingOptions>>("ProcessUnitOptions::ScoreThresholdingOptions", pos),
ProcessUnitOptions::BertTokenizerOptions => v.verify_union_variant::<flatbuffers::ForwardsUOffset<BertTokenizerOptions>>("ProcessUnitOptions::BertTokenizerOptions", pos),
ProcessUnitOptions::SentencePieceTokenizerOptions => v.verify_union_variant::<flatbuffers::ForwardsUOffset<SentencePieceTokenizerOptions>>("ProcessUnitOptions::SentencePieceTokenizerOptions", pos),
ProcessUnitOptions::RegexTokenizerOptions => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RegexTokenizerOptions>>("ProcessUnitOptions::RegexTokenizerOptions", pos),
_ => Ok(()),
}
})?
.finish();
Ok(())
}
}
pub struct ProcessUnitArgs {
pub options_type: ProcessUnitOptions,
pub options: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for ProcessUnitArgs {
#[inline]
fn default() -> Self {
ProcessUnitArgs {
options_type: ProcessUnitOptions::NONE,
options: None,
}
}
}
pub struct ProcessUnitBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ProcessUnitBuilder<'a, 'b, A> {
#[inline]
pub fn add_options_type(&mut self, options_type: ProcessUnitOptions) {
self.fbb_.push_slot::<ProcessUnitOptions>(
ProcessUnit::VT_OPTIONS_TYPE,
options_type,
ProcessUnitOptions::NONE,
);
}
#[inline]
pub fn add_options(
&mut self,
options: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(ProcessUnit::VT_OPTIONS, options);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> ProcessUnitBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ProcessUnitBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<ProcessUnit<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for ProcessUnit<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("ProcessUnit");
ds.field("options_type", &self.options_type());
match self.options_type() {
ProcessUnitOptions::NormalizationOptions => {
if let Some(x) = self.options_as_normalization_options() {
ds.field("options", &x)
} else {
ds.field(
"options",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
ProcessUnitOptions::ScoreCalibrationOptions => {
if let Some(x) = self.options_as_score_calibration_options() {
ds.field("options", &x)
} else {
ds.field(
"options",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
ProcessUnitOptions::ScoreThresholdingOptions => {
if let Some(x) = self.options_as_score_thresholding_options() {
ds.field("options", &x)
} else {
ds.field(
"options",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
ProcessUnitOptions::BertTokenizerOptions => {
if let Some(x) = self.options_as_bert_tokenizer_options() {
ds.field("options", &x)
} else {
ds.field(
"options",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
ProcessUnitOptions::SentencePieceTokenizerOptions => {
if let Some(x) = self.options_as_sentence_piece_tokenizer_options() {
ds.field("options", &x)
} else {
ds.field(
"options",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
ProcessUnitOptions::RegexTokenizerOptions => {
if let Some(x) = self.options_as_regex_tokenizer_options() {
ds.field("options", &x)
} else {
ds.field(
"options",
&"InvalidFlatbuffer: Union discriminant does not match value.",
)
}
}
_ => {
let x: Option<()> = None;
ds.field("options", &x)
}
};
ds.finish()
}
}
pub enum StatsOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Stats<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for Stats<'a> {
type Inner = Stats<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> Stats<'a> {
pub const VT_MAX: flatbuffers::VOffsetT = 4;
pub const VT_MIN: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
Stats { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args StatsArgs<'args>,
) -> flatbuffers::WIPOffset<Stats<'bldr>> {
let mut builder = StatsBuilder::new(_fbb);
if let Some(x) = args.min {
builder.add_min(x);
}
if let Some(x) = args.max {
builder.add_max(x);
}
builder.finish()
}
#[inline]
pub fn max(&self) -> Option<flatbuffers::Vector<'a, f32>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, f32>>>(
Stats::VT_MAX,
None,
)
}
}
#[inline]
pub fn min(&self) -> Option<flatbuffers::Vector<'a, f32>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, f32>>>(
Stats::VT_MIN,
None,
)
}
}
}
impl flatbuffers::Verifiable for Stats<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f32>>>(
"max",
Self::VT_MAX,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f32>>>(
"min",
Self::VT_MIN,
false,
)?
.finish();
Ok(())
}
}
pub struct StatsArgs<'a> {
pub max: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f32>>>,
pub min: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f32>>>,
}
impl<'a> Default for StatsArgs<'a> {
#[inline]
fn default() -> Self {
StatsArgs {
max: None,
min: None,
}
}
}
pub struct StatsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> StatsBuilder<'a, 'b, A> {
#[inline]
pub fn add_max(&mut self, max: flatbuffers::WIPOffset<flatbuffers::Vector<'b, f32>>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(Stats::VT_MAX, max);
}
#[inline]
pub fn add_min(&mut self, min: flatbuffers::WIPOffset<flatbuffers::Vector<'b, f32>>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(Stats::VT_MIN, min);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> StatsBuilder<'a, 'b, A> {
let start = _fbb.start_table();
StatsBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<Stats<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for Stats<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("Stats");
ds.field("max", &self.max());
ds.field("min", &self.min());
ds.finish()
}
}
pub enum TensorGroupOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct TensorGroup<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for TensorGroup<'a> {
type Inner = TensorGroup<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> TensorGroup<'a> {
pub const VT_NAME: flatbuffers::VOffsetT = 4;
pub const VT_TENSOR_NAMES: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
TensorGroup { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TensorGroupArgs<'args>,
) -> flatbuffers::WIPOffset<TensorGroup<'bldr>> {
let mut builder = TensorGroupBuilder::new(_fbb);
if let Some(x) = args.tensor_names {
builder.add_tensor_names(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(TensorGroup::VT_NAME, None)
}
}
#[inline]
pub fn tensor_names(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>,
>>(TensorGroup::VT_TENSOR_NAMES, None)
}
}
}
impl flatbuffers::Verifiable for TensorGroup<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>,
>>("tensor_names", Self::VT_TENSOR_NAMES, false)?
.finish();
Ok(())
}
}
pub struct TensorGroupArgs<'a> {
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
pub tensor_names: Option<
flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>,
>,
}
impl<'a> Default for TensorGroupArgs<'a> {
#[inline]
fn default() -> Self {
TensorGroupArgs {
name: None,
tensor_names: None,
}
}
}
pub struct TensorGroupBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TensorGroupBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(TensorGroup::VT_NAME, name);
}
#[inline]
pub fn add_tensor_names(
&mut self,
tensor_names: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
TensorGroup::VT_TENSOR_NAMES,
tensor_names,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> TensorGroupBuilder<'a, 'b, A> {
let start = _fbb.start_table();
TensorGroupBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<TensorGroup<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for TensorGroup<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("TensorGroup");
ds.field("name", &self.name());
ds.field("tensor_names", &self.tensor_names());
ds.finish()
}
}
pub enum TensorMetadataOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct TensorMetadata<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for TensorMetadata<'a> {
type Inner = TensorMetadata<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> TensorMetadata<'a> {
pub const VT_NAME: flatbuffers::VOffsetT = 4;
pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 6;
pub const VT_DIMENSION_NAMES: flatbuffers::VOffsetT = 8;
pub const VT_CONTENT: flatbuffers::VOffsetT = 10;
pub const VT_PROCESS_UNITS: flatbuffers::VOffsetT = 12;
pub const VT_STATS: flatbuffers::VOffsetT = 14;
pub const VT_ASSOCIATED_FILES: flatbuffers::VOffsetT = 16;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
TensorMetadata { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TensorMetadataArgs<'args>,
) -> flatbuffers::WIPOffset<TensorMetadata<'bldr>> {
let mut builder = TensorMetadataBuilder::new(_fbb);
if let Some(x) = args.associated_files {
builder.add_associated_files(x);
}
if let Some(x) = args.stats {
builder.add_stats(x);
}
if let Some(x) = args.process_units {
builder.add_process_units(x);
}
if let Some(x) = args.content {
builder.add_content(x);
}
if let Some(x) = args.dimension_names {
builder.add_dimension_names(x);
}
if let Some(x) = args.description {
builder.add_description(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(TensorMetadata::VT_NAME, None)
}
}
#[inline]
pub fn description(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(TensorMetadata::VT_DESCRIPTION, None)
}
}
#[inline]
pub fn dimension_names(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>,
>>(TensorMetadata::VT_DIMENSION_NAMES, None)
}
}
#[inline]
pub fn content(&self) -> Option<Content<'a>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<Content>>(TensorMetadata::VT_CONTENT, None)
}
}
#[inline]
pub fn process_units(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ProcessUnit<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ProcessUnit>>,
>>(TensorMetadata::VT_PROCESS_UNITS, None)
}
}
#[inline]
pub fn stats(&self) -> Option<Stats<'a>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<Stats>>(TensorMetadata::VT_STATS, None)
}
}
#[inline]
pub fn associated_files(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>(TensorMetadata::VT_ASSOCIATED_FILES, None)
}
}
}
impl flatbuffers::Verifiable for TensorMetadata<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"description",
Self::VT_DESCRIPTION,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>,
>>("dimension_names", Self::VT_DIMENSION_NAMES, false)?
.visit_field::<flatbuffers::ForwardsUOffset<Content>>(
"content",
Self::VT_CONTENT,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ProcessUnit>>,
>>("process_units", Self::VT_PROCESS_UNITS, false)?
.visit_field::<flatbuffers::ForwardsUOffset<Stats>>("stats", Self::VT_STATS, false)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>("associated_files", Self::VT_ASSOCIATED_FILES, false)?
.finish();
Ok(())
}
}
pub struct TensorMetadataArgs<'a> {
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
pub description: Option<flatbuffers::WIPOffset<&'a str>>,
pub dimension_names: Option<
flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>,
>,
pub content: Option<flatbuffers::WIPOffset<Content<'a>>>,
pub process_units: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ProcessUnit<'a>>>,
>,
>,
pub stats: Option<flatbuffers::WIPOffset<Stats<'a>>>,
pub associated_files: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>,
>,
>,
}
impl<'a> Default for TensorMetadataArgs<'a> {
#[inline]
fn default() -> Self {
TensorMetadataArgs {
name: None,
description: None,
dimension_names: None,
content: None,
process_units: None,
stats: None,
associated_files: None,
}
}
}
pub struct TensorMetadataBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> TensorMetadataBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(TensorMetadata::VT_NAME, name);
}
#[inline]
pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
TensorMetadata::VT_DESCRIPTION,
description,
);
}
#[inline]
pub fn add_dimension_names(
&mut self,
dimension_names: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
TensorMetadata::VT_DIMENSION_NAMES,
dimension_names,
);
}
#[inline]
pub fn add_content(&mut self, content: flatbuffers::WIPOffset<Content<'b>>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<Content>>(
TensorMetadata::VT_CONTENT,
content,
);
}
#[inline]
pub fn add_process_units(
&mut self,
process_units: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<ProcessUnit<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
TensorMetadata::VT_PROCESS_UNITS,
process_units,
);
}
#[inline]
pub fn add_stats(&mut self, stats: flatbuffers::WIPOffset<Stats<'b>>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<Stats>>(TensorMetadata::VT_STATS, stats);
}
#[inline]
pub fn add_associated_files(
&mut self,
associated_files: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<AssociatedFile<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
TensorMetadata::VT_ASSOCIATED_FILES,
associated_files,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> TensorMetadataBuilder<'a, 'b, A> {
let start = _fbb.start_table();
TensorMetadataBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<TensorMetadata<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for TensorMetadata<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("TensorMetadata");
ds.field("name", &self.name());
ds.field("description", &self.description());
ds.field("dimension_names", &self.dimension_names());
ds.field("content", &self.content());
ds.field("process_units", &self.process_units());
ds.field("stats", &self.stats());
ds.field("associated_files", &self.associated_files());
ds.finish()
}
}
pub enum CustomMetadataOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct CustomMetadata<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for CustomMetadata<'a> {
type Inner = CustomMetadata<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> CustomMetadata<'a> {
pub const VT_NAME: flatbuffers::VOffsetT = 4;
pub const VT_DATA: flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
CustomMetadata { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args CustomMetadataArgs<'args>,
) -> flatbuffers::WIPOffset<CustomMetadata<'bldr>> {
let mut builder = CustomMetadataBuilder::new(_fbb);
if let Some(x) = args.data {
builder.add_data(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(CustomMetadata::VT_NAME, None)
}
}
#[inline]
pub fn data(&self) -> Option<flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
CustomMetadata::VT_DATA,
None,
)
}
}
}
impl flatbuffers::Verifiable for CustomMetadata<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
"data",
Self::VT_DATA,
false,
)?
.finish();
Ok(())
}
}
pub struct CustomMetadataArgs<'a> {
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
pub data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for CustomMetadataArgs<'a> {
#[inline]
fn default() -> Self {
CustomMetadataArgs {
name: None,
data: None,
}
}
}
pub struct CustomMetadataBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> CustomMetadataBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(CustomMetadata::VT_NAME, name);
}
#[inline]
pub fn add_data(&mut self, data: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(CustomMetadata::VT_DATA, data);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> CustomMetadataBuilder<'a, 'b, A> {
let start = _fbb.start_table();
CustomMetadataBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<CustomMetadata<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for CustomMetadata<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("CustomMetadata");
ds.field("name", &self.name());
ds.field("data", &self.data());
ds.finish()
}
}
pub enum SubGraphMetadataOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct SubGraphMetadata<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for SubGraphMetadata<'a> {
type Inner = SubGraphMetadata<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> SubGraphMetadata<'a> {
pub const VT_NAME: flatbuffers::VOffsetT = 4;
pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 6;
pub const VT_INPUT_TENSOR_METADATA: flatbuffers::VOffsetT = 8;
pub const VT_OUTPUT_TENSOR_METADATA: flatbuffers::VOffsetT = 10;
pub const VT_ASSOCIATED_FILES: flatbuffers::VOffsetT = 12;
pub const VT_INPUT_PROCESS_UNITS: flatbuffers::VOffsetT = 14;
pub const VT_OUTPUT_PROCESS_UNITS: flatbuffers::VOffsetT = 16;
pub const VT_INPUT_TENSOR_GROUPS: flatbuffers::VOffsetT = 18;
pub const VT_OUTPUT_TENSOR_GROUPS: flatbuffers::VOffsetT = 20;
pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 22;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
SubGraphMetadata { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args SubGraphMetadataArgs<'args>,
) -> flatbuffers::WIPOffset<SubGraphMetadata<'bldr>> {
let mut builder = SubGraphMetadataBuilder::new(_fbb);
if let Some(x) = args.custom_metadata {
builder.add_custom_metadata(x);
}
if let Some(x) = args.output_tensor_groups {
builder.add_output_tensor_groups(x);
}
if let Some(x) = args.input_tensor_groups {
builder.add_input_tensor_groups(x);
}
if let Some(x) = args.output_process_units {
builder.add_output_process_units(x);
}
if let Some(x) = args.input_process_units {
builder.add_input_process_units(x);
}
if let Some(x) = args.associated_files {
builder.add_associated_files(x);
}
if let Some(x) = args.output_tensor_metadata {
builder.add_output_tensor_metadata(x);
}
if let Some(x) = args.input_tensor_metadata {
builder.add_input_tensor_metadata(x);
}
if let Some(x) = args.description {
builder.add_description(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(SubGraphMetadata::VT_NAME, None)
}
}
#[inline]
pub fn description(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(
SubGraphMetadata::VT_DESCRIPTION,
None,
)
}
}
#[inline]
pub fn input_tensor_metadata(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorMetadata<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorMetadata>>,
>>(SubGraphMetadata::VT_INPUT_TENSOR_METADATA, None)
}
}
#[inline]
pub fn output_tensor_metadata(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorMetadata<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorMetadata>>,
>>(SubGraphMetadata::VT_OUTPUT_TENSOR_METADATA, None)
}
}
#[inline]
pub fn associated_files(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>(SubGraphMetadata::VT_ASSOCIATED_FILES, None)
}
}
#[inline]
pub fn input_process_units(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ProcessUnit<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ProcessUnit>>,
>>(SubGraphMetadata::VT_INPUT_PROCESS_UNITS, None)
}
}
#[inline]
pub fn output_process_units(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ProcessUnit<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ProcessUnit>>,
>>(SubGraphMetadata::VT_OUTPUT_PROCESS_UNITS, None)
}
}
#[inline]
pub fn input_tensor_groups(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorGroup<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorGroup>>,
>>(SubGraphMetadata::VT_INPUT_TENSOR_GROUPS, None)
}
}
#[inline]
pub fn output_tensor_groups(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorGroup<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorGroup>>,
>>(SubGraphMetadata::VT_OUTPUT_TENSOR_GROUPS, None)
}
}
#[inline]
pub fn custom_metadata(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<CustomMetadata<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<CustomMetadata>>,
>>(SubGraphMetadata::VT_CUSTOM_METADATA, None)
}
}
}
impl flatbuffers::Verifiable for SubGraphMetadata<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"description",
Self::VT_DESCRIPTION,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TensorMetadata>>,
>>(
"input_tensor_metadata",
Self::VT_INPUT_TENSOR_METADATA,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TensorMetadata>>,
>>(
"output_tensor_metadata",
Self::VT_OUTPUT_TENSOR_METADATA,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>("associated_files", Self::VT_ASSOCIATED_FILES, false)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ProcessUnit>>,
>>("input_process_units", Self::VT_INPUT_PROCESS_UNITS, false)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ProcessUnit>>,
>>("output_process_units", Self::VT_OUTPUT_PROCESS_UNITS, false)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TensorGroup>>,
>>("input_tensor_groups", Self::VT_INPUT_TENSOR_GROUPS, false)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TensorGroup>>,
>>("output_tensor_groups", Self::VT_OUTPUT_TENSOR_GROUPS, false)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<CustomMetadata>>,
>>("custom_metadata", Self::VT_CUSTOM_METADATA, false)?
.finish();
Ok(())
}
}
pub struct SubGraphMetadataArgs<'a> {
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
pub description: Option<flatbuffers::WIPOffset<&'a str>>,
pub input_tensor_metadata: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorMetadata<'a>>>,
>,
>,
pub output_tensor_metadata: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorMetadata<'a>>>,
>,
>,
pub associated_files: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>,
>,
>,
pub input_process_units: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ProcessUnit<'a>>>,
>,
>,
pub output_process_units: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ProcessUnit<'a>>>,
>,
>,
pub input_tensor_groups: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorGroup<'a>>>,
>,
>,
pub output_tensor_groups: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorGroup<'a>>>,
>,
>,
pub custom_metadata: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<CustomMetadata<'a>>>,
>,
>,
}
impl<'a> Default for SubGraphMetadataArgs<'a> {
#[inline]
fn default() -> Self {
SubGraphMetadataArgs {
name: None,
description: None,
input_tensor_metadata: None,
output_tensor_metadata: None,
associated_files: None,
input_process_units: None,
output_process_units: None,
input_tensor_groups: None,
output_tensor_groups: None,
custom_metadata: None,
}
}
}
pub struct SubGraphMetadataBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> SubGraphMetadataBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(SubGraphMetadata::VT_NAME, name);
}
#[inline]
pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SubGraphMetadata::VT_DESCRIPTION,
description,
);
}
#[inline]
pub fn add_input_tensor_metadata(
&mut self,
input_tensor_metadata: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<TensorMetadata<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SubGraphMetadata::VT_INPUT_TENSOR_METADATA,
input_tensor_metadata,
);
}
#[inline]
pub fn add_output_tensor_metadata(
&mut self,
output_tensor_metadata: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<TensorMetadata<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SubGraphMetadata::VT_OUTPUT_TENSOR_METADATA,
output_tensor_metadata,
);
}
#[inline]
pub fn add_associated_files(
&mut self,
associated_files: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<AssociatedFile<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SubGraphMetadata::VT_ASSOCIATED_FILES,
associated_files,
);
}
#[inline]
pub fn add_input_process_units(
&mut self,
input_process_units: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<ProcessUnit<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SubGraphMetadata::VT_INPUT_PROCESS_UNITS,
input_process_units,
);
}
#[inline]
pub fn add_output_process_units(
&mut self,
output_process_units: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<ProcessUnit<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SubGraphMetadata::VT_OUTPUT_PROCESS_UNITS,
output_process_units,
);
}
#[inline]
pub fn add_input_tensor_groups(
&mut self,
input_tensor_groups: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<TensorGroup<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SubGraphMetadata::VT_INPUT_TENSOR_GROUPS,
input_tensor_groups,
);
}
#[inline]
pub fn add_output_tensor_groups(
&mut self,
output_tensor_groups: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<TensorGroup<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SubGraphMetadata::VT_OUTPUT_TENSOR_GROUPS,
output_tensor_groups,
);
}
#[inline]
pub fn add_custom_metadata(
&mut self,
custom_metadata: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<CustomMetadata<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
SubGraphMetadata::VT_CUSTOM_METADATA,
custom_metadata,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> SubGraphMetadataBuilder<'a, 'b, A> {
let start = _fbb.start_table();
SubGraphMetadataBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<SubGraphMetadata<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for SubGraphMetadata<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("SubGraphMetadata");
ds.field("name", &self.name());
ds.field("description", &self.description());
ds.field("input_tensor_metadata", &self.input_tensor_metadata());
ds.field("output_tensor_metadata", &self.output_tensor_metadata());
ds.field("associated_files", &self.associated_files());
ds.field("input_process_units", &self.input_process_units());
ds.field("output_process_units", &self.output_process_units());
ds.field("input_tensor_groups", &self.input_tensor_groups());
ds.field("output_tensor_groups", &self.output_tensor_groups());
ds.field("custom_metadata", &self.custom_metadata());
ds.finish()
}
}
pub enum ModelMetadataOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ModelMetadata<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for ModelMetadata<'a> {
type Inner = ModelMetadata<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ModelMetadata<'a> {
pub const VT_NAME: flatbuffers::VOffsetT = 4;
pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 6;
pub const VT_VERSION: flatbuffers::VOffsetT = 8;
pub const VT_SUBGRAPH_METADATA: flatbuffers::VOffsetT = 10;
pub const VT_AUTHOR: flatbuffers::VOffsetT = 12;
pub const VT_LICENSE: flatbuffers::VOffsetT = 14;
pub const VT_ASSOCIATED_FILES: flatbuffers::VOffsetT = 16;
pub const VT_MIN_PARSER_VERSION: flatbuffers::VOffsetT = 18;
#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
ModelMetadata { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ModelMetadataArgs<'args>,
) -> flatbuffers::WIPOffset<ModelMetadata<'bldr>> {
let mut builder = ModelMetadataBuilder::new(_fbb);
if let Some(x) = args.min_parser_version {
builder.add_min_parser_version(x);
}
if let Some(x) = args.associated_files {
builder.add_associated_files(x);
}
if let Some(x) = args.license {
builder.add_license(x);
}
if let Some(x) = args.author {
builder.add_author(x);
}
if let Some(x) = args.subgraph_metadata {
builder.add_subgraph_metadata(x);
}
if let Some(x) = args.version {
builder.add_version(x);
}
if let Some(x) = args.description {
builder.add_description(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(ModelMetadata::VT_NAME, None)
}
}
#[inline]
pub fn description(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(ModelMetadata::VT_DESCRIPTION, None)
}
}
#[inline]
pub fn version(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(ModelMetadata::VT_VERSION, None)
}
}
#[inline]
pub fn subgraph_metadata(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SubGraphMetadata<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SubGraphMetadata>>,
>>(ModelMetadata::VT_SUBGRAPH_METADATA, None)
}
}
#[inline]
pub fn author(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(ModelMetadata::VT_AUTHOR, None)
}
}
#[inline]
pub fn license(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<flatbuffers::ForwardsUOffset<&str>>(ModelMetadata::VT_LICENSE, None)
}
}
#[inline]
pub fn associated_files(
&self,
) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>>
{
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>(ModelMetadata::VT_ASSOCIATED_FILES, None)
}
}
#[inline]
pub fn min_parser_version(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(
ModelMetadata::VT_MIN_PARSER_VERSION,
None,
)
}
}
}
impl flatbuffers::Verifiable for ModelMetadata<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier,
pos: usize,
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"description",
Self::VT_DESCRIPTION,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"version",
Self::VT_VERSION,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<SubGraphMetadata>>,
>>("subgraph_metadata", Self::VT_SUBGRAPH_METADATA, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"author",
Self::VT_AUTHOR,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"license",
Self::VT_LICENSE,
false,
)?
.visit_field::<flatbuffers::ForwardsUOffset<
flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AssociatedFile>>,
>>("associated_files", Self::VT_ASSOCIATED_FILES, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(
"min_parser_version",
Self::VT_MIN_PARSER_VERSION,
false,
)?
.finish();
Ok(())
}
}
pub struct ModelMetadataArgs<'a> {
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
pub description: Option<flatbuffers::WIPOffset<&'a str>>,
pub version: Option<flatbuffers::WIPOffset<&'a str>>,
pub subgraph_metadata: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SubGraphMetadata<'a>>>,
>,
>,
pub author: Option<flatbuffers::WIPOffset<&'a str>>,
pub license: Option<flatbuffers::WIPOffset<&'a str>>,
pub associated_files: Option<
flatbuffers::WIPOffset<
flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AssociatedFile<'a>>>,
>,
>,
pub min_parser_version: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ModelMetadataArgs<'a> {
#[inline]
fn default() -> Self {
ModelMetadataArgs {
name: None,
description: None,
version: None,
subgraph_metadata: None,
author: None,
license: None,
associated_files: None,
min_parser_version: None,
}
}
}
pub struct ModelMetadataBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ModelMetadataBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(ModelMetadata::VT_NAME, name);
}
#[inline]
pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
ModelMetadata::VT_DESCRIPTION,
description,
);
}
#[inline]
pub fn add_version(&mut self, version: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(ModelMetadata::VT_VERSION, version);
}
#[inline]
pub fn add_subgraph_metadata(
&mut self,
subgraph_metadata: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<SubGraphMetadata<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
ModelMetadata::VT_SUBGRAPH_METADATA,
subgraph_metadata,
);
}
#[inline]
pub fn add_author(&mut self, author: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(ModelMetadata::VT_AUTHOR, author);
}
#[inline]
pub fn add_license(&mut self, license: flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<flatbuffers::WIPOffset<_>>(ModelMetadata::VT_LICENSE, license);
}
#[inline]
pub fn add_associated_files(
&mut self,
associated_files: flatbuffers::WIPOffset<
flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<AssociatedFile<'b>>>,
>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
ModelMetadata::VT_ASSOCIATED_FILES,
associated_files,
);
}
#[inline]
pub fn add_min_parser_version(
&mut self,
min_parser_version: flatbuffers::WIPOffset<&'b str>,
) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
ModelMetadata::VT_MIN_PARSER_VERSION,
min_parser_version,
);
}
#[inline]
pub fn new(
_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
) -> ModelMetadataBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ModelMetadataBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<ModelMetadata<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl core::fmt::Debug for ModelMetadata<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("ModelMetadata");
ds.field("name", &self.name());
ds.field("description", &self.description());
ds.field("version", &self.version());
ds.field("subgraph_metadata", &self.subgraph_metadata());
ds.field("author", &self.author());
ds.field("license", &self.license());
ds.field("associated_files", &self.associated_files());
ds.field("min_parser_version", &self.min_parser_version());
ds.finish()
}
}
#[inline]
pub fn root_as_model_metadata(
buf: &[u8],
) -> Result<ModelMetadata, flatbuffers::InvalidFlatbuffer> {
flatbuffers::root::<ModelMetadata>(buf)
}
#[inline]
pub fn size_prefixed_root_as_model_metadata(
buf: &[u8],
) -> Result<ModelMetadata, flatbuffers::InvalidFlatbuffer> {
flatbuffers::size_prefixed_root::<ModelMetadata>(buf)
}
#[inline]
pub fn root_as_model_metadata_with_opts<'b, 'o>(
opts: &'o flatbuffers::VerifierOptions,
buf: &'b [u8],
) -> Result<ModelMetadata<'b>, flatbuffers::InvalidFlatbuffer> {
flatbuffers::root_with_opts::<ModelMetadata<'b>>(opts, buf)
}
#[inline]
pub fn size_prefixed_root_as_model_metadata_with_opts<'b, 'o>(
opts: &'o flatbuffers::VerifierOptions,
buf: &'b [u8],
) -> Result<ModelMetadata<'b>, flatbuffers::InvalidFlatbuffer> {
flatbuffers::size_prefixed_root_with_opts::<ModelMetadata<'b>>(opts, buf)
}
#[inline]
pub unsafe fn root_as_model_metadata_unchecked(buf: &[u8]) -> ModelMetadata {
unsafe { flatbuffers::root_unchecked::<ModelMetadata>(buf) }
}
#[inline]
pub unsafe fn size_prefixed_root_as_model_metadata_unchecked(buf: &[u8]) -> ModelMetadata {
unsafe { flatbuffers::size_prefixed_root_unchecked::<ModelMetadata>(buf) }
}
pub const MODEL_METADATA_IDENTIFIER: &str = "M001";
#[inline]
pub fn model_metadata_buffer_has_identifier(buf: &[u8]) -> bool {
flatbuffers::buffer_has_identifier(buf, MODEL_METADATA_IDENTIFIER, false)
}
#[inline]
pub fn model_metadata_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
flatbuffers::buffer_has_identifier(buf, MODEL_METADATA_IDENTIFIER, true)
}
pub const MODEL_METADATA_EXTENSION: &str = "tflitemeta";
#[inline]
pub fn finish_model_metadata_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
root: flatbuffers::WIPOffset<ModelMetadata<'a>>,
) {
fbb.finish(root, Some(MODEL_METADATA_IDENTIFIER));
}
#[inline]
pub fn finish_size_prefixed_model_metadata_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
root: flatbuffers::WIPOffset<ModelMetadata<'a>>,
) {
fbb.finish_size_prefixed(root, Some(MODEL_METADATA_IDENTIFIER));
}
}