extern crate alloc;
#[allow(unused_imports, dead_code)]
pub mod generated {
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_NODE_DATA: u8 = 0;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MAX_NODE_DATA: u8 = 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_NODE_DATA: [NodeData; 3] =
[NodeData::NONE, NodeData::Array, NodeData::Group];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct NodeData(pub u8);
#[allow(non_upper_case_globals)]
impl NodeData {
pub const NONE: Self = Self(0);
pub const Array: Self = Self(1);
pub const Group: Self = Self(2);
pub const ENUM_MIN: u8 = 0;
pub const ENUM_MAX: u8 = 2;
pub const ENUM_VALUES: &'static [Self] = &[Self::NONE, Self::Array, Self::Group];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::NONE => Some("NONE"),
Self::Array => Some("Array"),
Self::Group => Some("Group"),
_ => None,
}
}
}
impl ::core::fmt::Debug for NodeData {
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 NodeData {
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 NodeData {
type Output = NodeData;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
}
}
impl ::flatbuffers::EndianScalar for NodeData {
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 NodeData {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
u8::run_verifier(v, pos)
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for NodeData {}
pub struct NodeDataUnionTableOffset {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_NODE_TYPE: u8 = 0;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MAX_NODE_TYPE: u8 = 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_NODE_TYPE: [NodeType; 2] = [NodeType::Group, NodeType::Array];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct NodeType(pub u8);
#[allow(non_upper_case_globals)]
impl NodeType {
pub const Group: Self = Self(0);
pub const Array: Self = Self(1);
pub const ENUM_MIN: u8 = 0;
pub const ENUM_MAX: u8 = 1;
pub const ENUM_VALUES: &'static [Self] = &[Self::Group, Self::Array];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::Group => Some("Group"),
Self::Array => Some("Array"),
_ => None,
}
}
}
impl ::core::fmt::Debug for NodeType {
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 NodeType {
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 NodeType {
type Output = NodeType;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
}
}
impl ::flatbuffers::EndianScalar for NodeType {
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 NodeType {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
u8::run_verifier(v, pos)
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for NodeType {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_REPO_AVAILABILITY: u8 = 0;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MAX_REPO_AVAILABILITY: u8 = 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_REPO_AVAILABILITY: [RepoAvailability; 3] =
[RepoAvailability::Online, RepoAvailability::ReadOnly, RepoAvailability::Offline];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct RepoAvailability(pub u8);
#[allow(non_upper_case_globals)]
impl RepoAvailability {
pub const Online: Self = Self(0);
pub const ReadOnly: Self = Self(1);
pub const Offline: Self = Self(2);
pub const ENUM_MIN: u8 = 0;
pub const ENUM_MAX: u8 = 2;
pub const ENUM_VALUES: &'static [Self] =
&[Self::Online, Self::ReadOnly, Self::Offline];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::Online => Some("Online"),
Self::ReadOnly => Some("ReadOnly"),
Self::Offline => Some("Offline"),
_ => None,
}
}
}
impl ::core::fmt::Debug for RepoAvailability {
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 RepoAvailability {
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 RepoAvailability {
type Output = RepoAvailability;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
}
}
impl ::flatbuffers::EndianScalar for RepoAvailability {
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 RepoAvailability {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
u8::run_verifier(v, pos)
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for RepoAvailability {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_UPDATE_TYPE: u8 = 0;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MAX_UPDATE_TYPE: u8 = 16;
#[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_UPDATE_TYPE: [UpdateType; 17] = [
UpdateType::NONE,
UpdateType::RepoInitializedUpdate,
UpdateType::RepoMigratedUpdate,
UpdateType::ConfigChangedUpdate,
UpdateType::MetadataChangedUpdate,
UpdateType::TagCreatedUpdate,
UpdateType::TagDeletedUpdate,
UpdateType::BranchCreatedUpdate,
UpdateType::BranchDeletedUpdate,
UpdateType::BranchResetUpdate,
UpdateType::NewCommitUpdate,
UpdateType::CommitAmendedUpdate,
UpdateType::NewDetachedSnapshotUpdate,
UpdateType::GCRanUpdate,
UpdateType::ExpirationRanUpdate,
UpdateType::FeatureFlagChangedUpdate,
UpdateType::RepoStatusChangedUpdate,
];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct UpdateType(pub u8);
#[allow(non_upper_case_globals)]
impl UpdateType {
pub const NONE: Self = Self(0);
pub const RepoInitializedUpdate: Self = Self(1);
pub const RepoMigratedUpdate: Self = Self(2);
pub const ConfigChangedUpdate: Self = Self(3);
pub const MetadataChangedUpdate: Self = Self(4);
pub const TagCreatedUpdate: Self = Self(5);
pub const TagDeletedUpdate: Self = Self(6);
pub const BranchCreatedUpdate: Self = Self(7);
pub const BranchDeletedUpdate: Self = Self(8);
pub const BranchResetUpdate: Self = Self(9);
pub const NewCommitUpdate: Self = Self(10);
pub const CommitAmendedUpdate: Self = Self(11);
pub const NewDetachedSnapshotUpdate: Self = Self(12);
pub const GCRanUpdate: Self = Self(13);
pub const ExpirationRanUpdate: Self = Self(14);
pub const FeatureFlagChangedUpdate: Self = Self(15);
pub const RepoStatusChangedUpdate: Self = Self(16);
pub const ENUM_MIN: u8 = 0;
pub const ENUM_MAX: u8 = 16;
pub const ENUM_VALUES: &'static [Self] = &[
Self::NONE,
Self::RepoInitializedUpdate,
Self::RepoMigratedUpdate,
Self::ConfigChangedUpdate,
Self::MetadataChangedUpdate,
Self::TagCreatedUpdate,
Self::TagDeletedUpdate,
Self::BranchCreatedUpdate,
Self::BranchDeletedUpdate,
Self::BranchResetUpdate,
Self::NewCommitUpdate,
Self::CommitAmendedUpdate,
Self::NewDetachedSnapshotUpdate,
Self::GCRanUpdate,
Self::ExpirationRanUpdate,
Self::FeatureFlagChangedUpdate,
Self::RepoStatusChangedUpdate,
];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::NONE => Some("NONE"),
Self::RepoInitializedUpdate => Some("RepoInitializedUpdate"),
Self::RepoMigratedUpdate => Some("RepoMigratedUpdate"),
Self::ConfigChangedUpdate => Some("ConfigChangedUpdate"),
Self::MetadataChangedUpdate => Some("MetadataChangedUpdate"),
Self::TagCreatedUpdate => Some("TagCreatedUpdate"),
Self::TagDeletedUpdate => Some("TagDeletedUpdate"),
Self::BranchCreatedUpdate => Some("BranchCreatedUpdate"),
Self::BranchDeletedUpdate => Some("BranchDeletedUpdate"),
Self::BranchResetUpdate => Some("BranchResetUpdate"),
Self::NewCommitUpdate => Some("NewCommitUpdate"),
Self::CommitAmendedUpdate => Some("CommitAmendedUpdate"),
Self::NewDetachedSnapshotUpdate => Some("NewDetachedSnapshotUpdate"),
Self::GCRanUpdate => Some("GCRanUpdate"),
Self::ExpirationRanUpdate => Some("ExpirationRanUpdate"),
Self::FeatureFlagChangedUpdate => Some("FeatureFlagChangedUpdate"),
Self::RepoStatusChangedUpdate => Some("RepoStatusChangedUpdate"),
_ => None,
}
}
}
impl ::core::fmt::Debug for UpdateType {
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 UpdateType {
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 UpdateType {
type Output = UpdateType;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
}
}
impl ::flatbuffers::EndianScalar for UpdateType {
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 UpdateType {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
u8::run_verifier(v, pos)
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for UpdateType {}
pub struct UpdateTypeUnionTableOffset {}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct ObjectId12(pub [u8; 12]);
impl Default for ObjectId12 {
fn default() -> Self {
Self([0; 12])
}
}
impl ::core::fmt::Debug for ObjectId12 {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
f.debug_struct("ObjectId12").field("bytes", &self.bytes()).finish()
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for ObjectId12 {}
impl<'a> ::flatbuffers::Follow<'a> for ObjectId12 {
type Inner = &'a ObjectId12;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { <&'a ObjectId12>::follow(buf, loc) }
}
}
impl<'a> ::flatbuffers::Follow<'a> for &'a ObjectId12 {
type Inner = &'a ObjectId12;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { ::flatbuffers::follow_cast_ref::<ObjectId12>(buf, loc) }
}
}
impl<'b> ::flatbuffers::Push for ObjectId12 {
type Output = ObjectId12;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
let src = unsafe {
::core::slice::from_raw_parts(
self as *const ObjectId12 as *const u8,
<Self as ::flatbuffers::Push>::size(),
)
};
dst.copy_from_slice(src);
}
#[inline]
fn alignment() -> ::flatbuffers::PushAlignment {
::flatbuffers::PushAlignment::new(1)
}
}
impl<'a> ::flatbuffers::Verifiable for ObjectId12 {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.in_buffer::<Self>(pos)
}
}
impl<'a> ObjectId12 {
#[allow(clippy::too_many_arguments)]
pub fn new(bytes: &[u8; 12]) -> Self {
let mut s = Self([0; 12]);
s.set_bytes(bytes);
s
}
pub fn bytes(&'a self) -> ::flatbuffers::Array<'a, u8, 12> {
use ::flatbuffers::Follow;
unsafe { ::flatbuffers::Array::follow(&self.0, 0) }
}
pub fn set_bytes(&mut self, items: &[u8; 12]) {
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) };
}
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct ObjectId8(pub [u8; 8]);
impl Default for ObjectId8 {
fn default() -> Self {
Self([0; 8])
}
}
impl ::core::fmt::Debug for ObjectId8 {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
f.debug_struct("ObjectId8").field("bytes", &self.bytes()).finish()
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for ObjectId8 {}
impl<'a> ::flatbuffers::Follow<'a> for ObjectId8 {
type Inner = &'a ObjectId8;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { <&'a ObjectId8>::follow(buf, loc) }
}
}
impl<'a> ::flatbuffers::Follow<'a> for &'a ObjectId8 {
type Inner = &'a ObjectId8;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { ::flatbuffers::follow_cast_ref::<ObjectId8>(buf, loc) }
}
}
impl<'b> ::flatbuffers::Push for ObjectId8 {
type Output = ObjectId8;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
let src = unsafe {
::core::slice::from_raw_parts(
self as *const ObjectId8 as *const u8,
<Self as ::flatbuffers::Push>::size(),
)
};
dst.copy_from_slice(src);
}
#[inline]
fn alignment() -> ::flatbuffers::PushAlignment {
::flatbuffers::PushAlignment::new(1)
}
}
impl<'a> ::flatbuffers::Verifiable for ObjectId8 {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.in_buffer::<Self>(pos)
}
}
impl<'a> ObjectId8 {
#[allow(clippy::too_many_arguments)]
pub fn new(bytes: &[u8; 8]) -> Self {
let mut s = Self([0; 8]);
s.set_bytes(bytes);
s
}
pub fn bytes(&'a self) -> ::flatbuffers::Array<'a, u8, 8> {
use ::flatbuffers::Follow;
unsafe { ::flatbuffers::Array::follow(&self.0, 0) }
}
pub fn set_bytes(&mut self, items: &[u8; 8]) {
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) };
}
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct ManifestFileInfo(pub [u8; 32]);
impl Default for ManifestFileInfo {
fn default() -> Self {
Self([0; 32])
}
}
impl ::core::fmt::Debug for ManifestFileInfo {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
f.debug_struct("ManifestFileInfo")
.field("id", &self.id())
.field("size_bytes", &self.size_bytes())
.field("num_chunk_refs", &self.num_chunk_refs())
.finish()
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for ManifestFileInfo {}
impl<'a> ::flatbuffers::Follow<'a> for ManifestFileInfo {
type Inner = &'a ManifestFileInfo;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { <&'a ManifestFileInfo>::follow(buf, loc) }
}
}
impl<'a> ::flatbuffers::Follow<'a> for &'a ManifestFileInfo {
type Inner = &'a ManifestFileInfo;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { ::flatbuffers::follow_cast_ref::<ManifestFileInfo>(buf, loc) }
}
}
impl<'b> ::flatbuffers::Push for ManifestFileInfo {
type Output = ManifestFileInfo;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
let src = unsafe {
::core::slice::from_raw_parts(
self as *const ManifestFileInfo as *const u8,
<Self as ::flatbuffers::Push>::size(),
)
};
dst.copy_from_slice(src);
}
#[inline]
fn alignment() -> ::flatbuffers::PushAlignment {
::flatbuffers::PushAlignment::new(8)
}
}
impl<'a> ::flatbuffers::Verifiable for ManifestFileInfo {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.in_buffer::<Self>(pos)
}
}
impl<'a> ManifestFileInfo {
#[allow(clippy::too_many_arguments)]
pub fn new(id: &ObjectId12, size_bytes: u64, num_chunk_refs: u32) -> Self {
let mut s = Self([0; 32]);
s.set_id(id);
s.set_size_bytes(size_bytes);
s.set_num_chunk_refs(num_chunk_refs);
s
}
pub fn id(&self) -> &ObjectId12 {
unsafe { &*(self.0[0..].as_ptr() as *const ObjectId12) }
}
#[allow(clippy::identity_op)]
pub fn set_id(&mut self, x: &ObjectId12) {
self.0[0..0 + 12].copy_from_slice(&x.0)
}
pub fn size_bytes(&self) -> u64 {
let mut mem = ::core::mem::MaybeUninit::<
<u64 as ::flatbuffers::EndianScalar>::Scalar,
>::uninit();
::flatbuffers::EndianScalar::from_little_endian(unsafe {
::core::ptr::copy_nonoverlapping(
self.0[16..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
mem.assume_init()
})
}
pub fn set_size_bytes(&mut self, x: u64) {
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
unsafe {
::core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[16..].as_mut_ptr(),
::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
}
}
pub fn num_chunk_refs(&self) -> u32 {
let mut mem = ::core::mem::MaybeUninit::<
<u32 as ::flatbuffers::EndianScalar>::Scalar,
>::uninit();
::flatbuffers::EndianScalar::from_little_endian(unsafe {
::core::ptr::copy_nonoverlapping(
self.0[24..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
mem.assume_init()
})
}
pub fn set_num_chunk_refs(&mut self, x: u32) {
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
unsafe {
::core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[24..].as_mut_ptr(),
::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
}
}
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct ChunkIndexRange(pub [u8; 8]);
impl Default for ChunkIndexRange {
fn default() -> Self {
Self([0; 8])
}
}
impl ::core::fmt::Debug for ChunkIndexRange {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
f.debug_struct("ChunkIndexRange")
.field("from", &self.from())
.field("to", &self.to())
.finish()
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for ChunkIndexRange {}
impl<'a> ::flatbuffers::Follow<'a> for ChunkIndexRange {
type Inner = &'a ChunkIndexRange;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { <&'a ChunkIndexRange>::follow(buf, loc) }
}
}
impl<'a> ::flatbuffers::Follow<'a> for &'a ChunkIndexRange {
type Inner = &'a ChunkIndexRange;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { ::flatbuffers::follow_cast_ref::<ChunkIndexRange>(buf, loc) }
}
}
impl<'b> ::flatbuffers::Push for ChunkIndexRange {
type Output = ChunkIndexRange;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
let src = unsafe {
::core::slice::from_raw_parts(
self as *const ChunkIndexRange as *const u8,
<Self as ::flatbuffers::Push>::size(),
)
};
dst.copy_from_slice(src);
}
#[inline]
fn alignment() -> ::flatbuffers::PushAlignment {
::flatbuffers::PushAlignment::new(4)
}
}
impl<'a> ::flatbuffers::Verifiable for ChunkIndexRange {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.in_buffer::<Self>(pos)
}
}
impl<'a> ChunkIndexRange {
#[allow(clippy::too_many_arguments)]
pub fn new(from: u32, to: u32) -> Self {
let mut s = Self([0; 8]);
s.set_from(from);
s.set_to(to);
s
}
pub fn from(&self) -> u32 {
let mut mem = ::core::mem::MaybeUninit::<
<u32 as ::flatbuffers::EndianScalar>::Scalar,
>::uninit();
::flatbuffers::EndianScalar::from_little_endian(unsafe {
::core::ptr::copy_nonoverlapping(
self.0[0..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
mem.assume_init()
})
}
pub fn set_from(&mut self, x: u32) {
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
unsafe {
::core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[0..].as_mut_ptr(),
::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
}
}
pub fn to(&self) -> u32 {
let mut mem = ::core::mem::MaybeUninit::<
<u32 as ::flatbuffers::EndianScalar>::Scalar,
>::uninit();
::flatbuffers::EndianScalar::from_little_endian(unsafe {
::core::ptr::copy_nonoverlapping(
self.0[4..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
mem.assume_init()
})
}
pub fn set_to(&mut self, x: u32) {
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
unsafe {
::core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[4..].as_mut_ptr(),
::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
}
}
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct DimensionShape(pub [u8; 16]);
impl Default for DimensionShape {
fn default() -> Self {
Self([0; 16])
}
}
impl ::core::fmt::Debug for DimensionShape {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
f.debug_struct("DimensionShape")
.field("array_length", &self.array_length())
.field("chunk_length", &self.chunk_length())
.finish()
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for DimensionShape {}
impl<'a> ::flatbuffers::Follow<'a> for DimensionShape {
type Inner = &'a DimensionShape;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { <&'a DimensionShape>::follow(buf, loc) }
}
}
impl<'a> ::flatbuffers::Follow<'a> for &'a DimensionShape {
type Inner = &'a DimensionShape;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
unsafe { ::flatbuffers::follow_cast_ref::<DimensionShape>(buf, loc) }
}
}
impl<'b> ::flatbuffers::Push for DimensionShape {
type Output = DimensionShape;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
let src = unsafe {
::core::slice::from_raw_parts(
self as *const DimensionShape as *const u8,
<Self as ::flatbuffers::Push>::size(),
)
};
dst.copy_from_slice(src);
}
#[inline]
fn alignment() -> ::flatbuffers::PushAlignment {
::flatbuffers::PushAlignment::new(8)
}
}
impl<'a> ::flatbuffers::Verifiable for DimensionShape {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.in_buffer::<Self>(pos)
}
}
impl<'a> DimensionShape {
#[allow(clippy::too_many_arguments)]
pub fn new(array_length: u64, chunk_length: u64) -> Self {
let mut s = Self([0; 16]);
s.set_array_length(array_length);
s.set_chunk_length(chunk_length);
s
}
pub fn array_length(&self) -> u64 {
let mut mem = ::core::mem::MaybeUninit::<
<u64 as ::flatbuffers::EndianScalar>::Scalar,
>::uninit();
::flatbuffers::EndianScalar::from_little_endian(unsafe {
::core::ptr::copy_nonoverlapping(
self.0[0..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
mem.assume_init()
})
}
pub fn set_array_length(&mut self, x: u64) {
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
unsafe {
::core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[0..].as_mut_ptr(),
::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
}
}
pub fn chunk_length(&self) -> u64 {
let mut mem = ::core::mem::MaybeUninit::<
<u64 as ::flatbuffers::EndianScalar>::Scalar,
>::uninit();
::flatbuffers::EndianScalar::from_little_endian(unsafe {
::core::ptr::copy_nonoverlapping(
self.0[8..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
mem.assume_init()
})
}
pub fn set_chunk_length(&mut self, x: u64) {
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
unsafe {
::core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[8..].as_mut_ptr(),
::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(
),
);
}
}
}
pub enum MetadataItemOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct MetadataItem<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for MetadataItem<'a> {
type Inner = MetadataItem<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> MetadataItem<'a> {
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
pub const VT_VALUE: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
MetadataItem { _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 MetadataItemArgs<'args>,
) -> ::flatbuffers::WIPOffset<MetadataItem<'bldr>> {
let mut builder = MetadataItemBuilder::new(_fbb);
if let Some(x) = args.value {
builder.add_value(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
MetadataItem::VT_NAME,
None,
)
.unwrap()
}
}
#[inline]
pub fn value(&self) -> ::flatbuffers::Vector<'a, u8> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
MetadataItem::VT_VALUE,
None,
)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for MetadataItem<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("value", Self::VT_VALUE, true)?
.finish();
Ok(())
}
}
pub struct MetadataItemArgs<'a> {
pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
pub value: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for MetadataItemArgs<'a> {
#[inline]
fn default() -> Self {
MetadataItemArgs {
name: None, value: None, }
}
}
pub struct MetadataItemBuilder<'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> MetadataItemBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
MetadataItem::VT_NAME,
name,
);
}
#[inline]
pub fn add_value(
&mut self,
value: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
MetadataItem::VT_VALUE,
value,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> MetadataItemBuilder<'a, 'b, A> {
let start = _fbb.start_table();
MetadataItemBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<MetadataItem<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, MetadataItem::VT_NAME, "name");
self.fbb_.required(o, MetadataItem::VT_VALUE, "value");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for MetadataItem<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("MetadataItem");
ds.field("name", &self.name());
ds.field("value", &self.value());
ds.finish()
}
}
pub enum ChunkRefOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ChunkRef<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ChunkRef<'a> {
type Inner = ChunkRef<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> ChunkRef<'a> {
pub const VT_INDEX: ::flatbuffers::VOffsetT = 4;
pub const VT_INLINE: ::flatbuffers::VOffsetT = 6;
pub const VT_OFFSET: ::flatbuffers::VOffsetT = 8;
pub const VT_LENGTH: ::flatbuffers::VOffsetT = 10;
pub const VT_CHUNK_ID: ::flatbuffers::VOffsetT = 12;
pub const VT_LOCATION: ::flatbuffers::VOffsetT = 14;
pub const VT_CHECKSUM_ETAG: ::flatbuffers::VOffsetT = 16;
pub const VT_CHECKSUM_LAST_MODIFIED: ::flatbuffers::VOffsetT = 18;
pub const VT_COMPRESSED_LOCATION: ::flatbuffers::VOffsetT = 20;
pub const VT_EXTRA: ::flatbuffers::VOffsetT = 22;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ChunkRef { _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 ChunkRefArgs<'args>,
) -> ::flatbuffers::WIPOffset<ChunkRef<'bldr>> {
let mut builder = ChunkRefBuilder::new(_fbb);
builder.add_length(args.length);
builder.add_offset(args.offset);
if let Some(x) = args.extra {
builder.add_extra(x);
}
if let Some(x) = args.compressed_location {
builder.add_compressed_location(x);
}
builder.add_checksum_last_modified(args.checksum_last_modified);
if let Some(x) = args.checksum_etag {
builder.add_checksum_etag(x);
}
if let Some(x) = args.location {
builder.add_location(x);
}
if let Some(x) = args.chunk_id {
builder.add_chunk_id(x);
}
if let Some(x) = args.inline {
builder.add_inline(x);
}
if let Some(x) = args.index {
builder.add_index(x);
}
builder.finish()
}
#[inline]
pub fn index(&self) -> ::flatbuffers::Vector<'a, u32> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u32>>>(ChunkRef::VT_INDEX, None).unwrap()
}
}
#[inline]
pub fn inline(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
ChunkRef::VT_INLINE,
None,
)
}
}
#[inline]
pub fn offset(&self) -> u64 {
unsafe { self._tab.get::<u64>(ChunkRef::VT_OFFSET, Some(0)).unwrap() }
}
#[inline]
pub fn length(&self) -> u64 {
unsafe { self._tab.get::<u64>(ChunkRef::VT_LENGTH, Some(0)).unwrap() }
}
#[inline]
pub fn chunk_id(&self) -> Option<&'a ObjectId12> {
unsafe { self._tab.get::<ObjectId12>(ChunkRef::VT_CHUNK_ID, None) }
}
#[inline]
pub fn location(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
ChunkRef::VT_LOCATION,
None,
)
}
}
#[inline]
pub fn checksum_etag(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
ChunkRef::VT_CHECKSUM_ETAG,
None,
)
}
}
#[inline]
pub fn checksum_last_modified(&self) -> u32 {
unsafe {
self._tab
.get::<u32>(ChunkRef::VT_CHECKSUM_LAST_MODIFIED, Some(0))
.unwrap()
}
}
#[inline]
pub fn compressed_location(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
ChunkRef::VT_COMPRESSED_LOCATION,
None,
)
}
}
#[inline]
pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
ChunkRef::VT_EXTRA,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for ChunkRef<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u32>>>("index", Self::VT_INDEX, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("inline", Self::VT_INLINE, false)?
.visit_field::<u64>("offset", Self::VT_OFFSET, false)?
.visit_field::<u64>("length", Self::VT_LENGTH, false)?
.visit_field::<ObjectId12>("chunk_id", Self::VT_CHUNK_ID, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("location", Self::VT_LOCATION, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("checksum_etag", Self::VT_CHECKSUM_ETAG, false)?
.visit_field::<u32>("checksum_last_modified", Self::VT_CHECKSUM_LAST_MODIFIED, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("compressed_location", Self::VT_COMPRESSED_LOCATION, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("extra", Self::VT_EXTRA, false)?
.finish();
Ok(())
}
}
pub struct ChunkRefArgs<'a> {
pub index: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u32>>>,
pub inline: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
pub offset: u64,
pub length: u64,
pub chunk_id: Option<&'a ObjectId12>,
pub location: Option<::flatbuffers::WIPOffset<&'a str>>,
pub checksum_etag: Option<::flatbuffers::WIPOffset<&'a str>>,
pub checksum_last_modified: u32,
pub compressed_location:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for ChunkRefArgs<'a> {
#[inline]
fn default() -> Self {
ChunkRefArgs {
index: None, inline: None,
offset: 0,
length: 0,
chunk_id: None,
location: None,
checksum_etag: None,
checksum_last_modified: 0,
compressed_location: None,
extra: None,
}
}
}
pub struct ChunkRefBuilder<'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> ChunkRefBuilder<'a, 'b, A> {
#[inline]
pub fn add_index(
&mut self,
index: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u32>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ChunkRef::VT_INDEX,
index,
);
}
#[inline]
pub fn add_inline(
&mut self,
inline: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ChunkRef::VT_INLINE,
inline,
);
}
#[inline]
pub fn add_offset(&mut self, offset: u64) {
self.fbb_.push_slot::<u64>(ChunkRef::VT_OFFSET, offset, 0);
}
#[inline]
pub fn add_length(&mut self, length: u64) {
self.fbb_.push_slot::<u64>(ChunkRef::VT_LENGTH, length, 0);
}
#[inline]
pub fn add_chunk_id(&mut self, chunk_id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(ChunkRef::VT_CHUNK_ID, chunk_id);
}
#[inline]
pub fn add_location(&mut self, location: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ChunkRef::VT_LOCATION,
location,
);
}
#[inline]
pub fn add_checksum_etag(
&mut self,
checksum_etag: ::flatbuffers::WIPOffset<&'b str>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ChunkRef::VT_CHECKSUM_ETAG,
checksum_etag,
);
}
#[inline]
pub fn add_checksum_last_modified(&mut self, checksum_last_modified: u32) {
self.fbb_.push_slot::<u32>(
ChunkRef::VT_CHECKSUM_LAST_MODIFIED,
checksum_last_modified,
0,
);
}
#[inline]
pub fn add_compressed_location(
&mut self,
compressed_location: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ChunkRef::VT_COMPRESSED_LOCATION,
compressed_location,
);
}
#[inline]
pub fn add_extra(
&mut self,
extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ChunkRef::VT_EXTRA,
extra,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ChunkRefBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ChunkRefBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ChunkRef<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, ChunkRef::VT_INDEX, "index");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ChunkRef<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ChunkRef");
ds.field("index", &self.index());
ds.field("inline", &self.inline());
ds.field("offset", &self.offset());
ds.field("length", &self.length());
ds.field("chunk_id", &self.chunk_id());
ds.field("location", &self.location());
ds.field("checksum_etag", &self.checksum_etag());
ds.field("checksum_last_modified", &self.checksum_last_modified());
ds.field("compressed_location", &self.compressed_location());
ds.field("extra", &self.extra());
ds.finish()
}
}
pub enum ArrayManifestOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ArrayManifest<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ArrayManifest<'a> {
type Inner = ArrayManifest<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> ArrayManifest<'a> {
pub const VT_NODE_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_REFS: ::flatbuffers::VOffsetT = 6;
pub const VT_EXTRA: ::flatbuffers::VOffsetT = 8;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ArrayManifest { _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 ArrayManifestArgs<'args>,
) -> ::flatbuffers::WIPOffset<ArrayManifest<'bldr>> {
let mut builder = ArrayManifestBuilder::new(_fbb);
if let Some(x) = args.extra {
builder.add_extra(x);
}
if let Some(x) = args.refs {
builder.add_refs(x);
}
if let Some(x) = args.node_id {
builder.add_node_id(x);
}
builder.finish()
}
#[inline]
pub fn node_id(&self) -> &'a ObjectId8 {
unsafe {
self._tab.get::<ObjectId8>(ArrayManifest::VT_NODE_ID, None).unwrap()
}
}
#[inline]
pub fn refs(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ChunkRef<'a>>>
{
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ChunkRef>,
>,
>>(ArrayManifest::VT_REFS, None)
.unwrap()
}
}
#[inline]
pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
ArrayManifest::VT_EXTRA,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for ArrayManifest<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId8>("node_id", Self::VT_NODE_ID, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ChunkRef>>>>("refs", Self::VT_REFS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("extra", Self::VT_EXTRA, false)?
.finish();
Ok(())
}
}
pub struct ArrayManifestArgs<'a> {
pub node_id: Option<&'a ObjectId8>,
pub refs: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ChunkRef<'a>>>,
>,
>,
pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for ArrayManifestArgs<'a> {
#[inline]
fn default() -> Self {
ArrayManifestArgs {
node_id: None, refs: None, extra: None,
}
}
}
pub struct ArrayManifestBuilder<'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> ArrayManifestBuilder<'a, 'b, A> {
#[inline]
pub fn add_node_id(&mut self, node_id: &ObjectId8) {
self.fbb_.push_slot_always::<&ObjectId8>(ArrayManifest::VT_NODE_ID, node_id);
}
#[inline]
pub fn add_refs(
&mut self,
refs: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ChunkRef<'b>>>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ArrayManifest::VT_REFS,
refs,
);
}
#[inline]
pub fn add_extra(
&mut self,
extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ArrayManifest::VT_EXTRA,
extra,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ArrayManifestBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ArrayManifestBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ArrayManifest<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, ArrayManifest::VT_NODE_ID, "node_id");
self.fbb_.required(o, ArrayManifest::VT_REFS, "refs");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ArrayManifest<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ArrayManifest");
ds.field("node_id", &self.node_id());
ds.field("refs", &self.refs());
ds.field("extra", &self.extra());
ds.finish()
}
}
pub enum ManifestOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Manifest<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for Manifest<'a> {
type Inner = Manifest<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> Manifest<'a> {
pub const VT_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_ARRAYS: ::flatbuffers::VOffsetT = 6;
pub const VT_LOCATION_DICTIONARY: ::flatbuffers::VOffsetT = 8;
pub const VT_COMPRESSION_ALGORITHM: ::flatbuffers::VOffsetT = 10;
pub const VT_EXTRA: ::flatbuffers::VOffsetT = 12;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
Manifest { _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 ManifestArgs<'args>,
) -> ::flatbuffers::WIPOffset<Manifest<'bldr>> {
let mut builder = ManifestBuilder::new(_fbb);
if let Some(x) = args.extra {
builder.add_extra(x);
}
if let Some(x) = args.location_dictionary {
builder.add_location_dictionary(x);
}
if let Some(x) = args.arrays {
builder.add_arrays(x);
}
if let Some(x) = args.id {
builder.add_id(x);
}
builder.add_compression_algorithm(args.compression_algorithm);
builder.finish()
}
#[inline]
pub fn id(&self) -> &'a ObjectId12 {
unsafe { self._tab.get::<ObjectId12>(Manifest::VT_ID, None).unwrap() }
}
#[inline]
pub fn arrays(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ArrayManifest<'a>>>
{
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ArrayManifest>,
>,
>>(Manifest::VT_ARRAYS, None)
.unwrap()
}
}
#[inline]
pub fn location_dictionary(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
Manifest::VT_LOCATION_DICTIONARY,
None,
)
}
}
#[inline]
pub fn compression_algorithm(&self) -> u8 {
unsafe {
self._tab.get::<u8>(Manifest::VT_COMPRESSION_ALGORITHM, Some(1)).unwrap()
}
}
#[inline]
pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
Manifest::VT_EXTRA,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for Manifest<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId12>("id", Self::VT_ID, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ArrayManifest>>>>("arrays", Self::VT_ARRAYS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("location_dictionary", Self::VT_LOCATION_DICTIONARY, false)?
.visit_field::<u8>("compression_algorithm", Self::VT_COMPRESSION_ALGORITHM, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("extra", Self::VT_EXTRA, false)?
.finish();
Ok(())
}
}
pub struct ManifestArgs<'a> {
pub id: Option<&'a ObjectId12>,
pub arrays: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ArrayManifest<'a>>,
>,
>,
>,
pub location_dictionary:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
pub compression_algorithm: u8,
pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for ManifestArgs<'a> {
#[inline]
fn default() -> Self {
ManifestArgs {
id: None, arrays: None, location_dictionary: None,
compression_algorithm: 1,
extra: None,
}
}
}
pub struct ManifestBuilder<'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> ManifestBuilder<'a, 'b, A> {
#[inline]
pub fn add_id(&mut self, id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(Manifest::VT_ID, id);
}
#[inline]
pub fn add_arrays(
&mut self,
arrays: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<ArrayManifest<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Manifest::VT_ARRAYS,
arrays,
);
}
#[inline]
pub fn add_location_dictionary(
&mut self,
location_dictionary: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Manifest::VT_LOCATION_DICTIONARY,
location_dictionary,
);
}
#[inline]
pub fn add_compression_algorithm(&mut self, compression_algorithm: u8) {
self.fbb_.push_slot::<u8>(
Manifest::VT_COMPRESSION_ALGORITHM,
compression_algorithm,
1,
);
}
#[inline]
pub fn add_extra(
&mut self,
extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Manifest::VT_EXTRA,
extra,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ManifestBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ManifestBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<Manifest<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, Manifest::VT_ID, "id");
self.fbb_.required(o, Manifest::VT_ARRAYS, "arrays");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for Manifest<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("Manifest");
ds.field("id", &self.id());
ds.field("arrays", &self.arrays());
ds.field("location_dictionary", &self.location_dictionary());
ds.field("compression_algorithm", &self.compression_algorithm());
ds.field("extra", &self.extra());
ds.finish()
}
}
pub enum ManifestFileInfoV2Offset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ManifestFileInfoV2<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ManifestFileInfoV2<'a> {
type Inner = ManifestFileInfoV2<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> ManifestFileInfoV2<'a> {
pub const VT_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_SIZE_BYTES: ::flatbuffers::VOffsetT = 6;
pub const VT_NUM_CHUNK_REFS: ::flatbuffers::VOffsetT = 8;
pub const VT_EXTRA: ::flatbuffers::VOffsetT = 10;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ManifestFileInfoV2 { _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 ManifestFileInfoV2Args<'args>,
) -> ::flatbuffers::WIPOffset<ManifestFileInfoV2<'bldr>> {
let mut builder = ManifestFileInfoV2Builder::new(_fbb);
builder.add_size_bytes(args.size_bytes);
if let Some(x) = args.extra {
builder.add_extra(x);
}
builder.add_num_chunk_refs(args.num_chunk_refs);
if let Some(x) = args.id {
builder.add_id(x);
}
builder.finish()
}
#[inline]
pub fn id(&self) -> Option<&'a ObjectId12> {
unsafe { self._tab.get::<ObjectId12>(ManifestFileInfoV2::VT_ID, None) }
}
#[inline]
pub fn size_bytes(&self) -> u64 {
unsafe {
self._tab.get::<u64>(ManifestFileInfoV2::VT_SIZE_BYTES, Some(0)).unwrap()
}
}
#[inline]
pub fn num_chunk_refs(&self) -> u32 {
unsafe {
self._tab
.get::<u32>(ManifestFileInfoV2::VT_NUM_CHUNK_REFS, Some(0))
.unwrap()
}
}
#[inline]
pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
ManifestFileInfoV2::VT_EXTRA,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for ManifestFileInfoV2<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId12>("id", Self::VT_ID, false)?
.visit_field::<u64>("size_bytes", Self::VT_SIZE_BYTES, false)?
.visit_field::<u32>("num_chunk_refs", Self::VT_NUM_CHUNK_REFS, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("extra", Self::VT_EXTRA, false)?
.finish();
Ok(())
}
}
pub struct ManifestFileInfoV2Args<'a> {
pub id: Option<&'a ObjectId12>,
pub size_bytes: u64,
pub num_chunk_refs: u32,
pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for ManifestFileInfoV2Args<'a> {
#[inline]
fn default() -> Self {
ManifestFileInfoV2Args {
id: None,
size_bytes: 0,
num_chunk_refs: 0,
extra: None,
}
}
}
pub struct ManifestFileInfoV2Builder<'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> ManifestFileInfoV2Builder<'a, 'b, A> {
#[inline]
pub fn add_id(&mut self, id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(ManifestFileInfoV2::VT_ID, id);
}
#[inline]
pub fn add_size_bytes(&mut self, size_bytes: u64) {
self.fbb_.push_slot::<u64>(ManifestFileInfoV2::VT_SIZE_BYTES, size_bytes, 0);
}
#[inline]
pub fn add_num_chunk_refs(&mut self, num_chunk_refs: u32) {
self.fbb_.push_slot::<u32>(
ManifestFileInfoV2::VT_NUM_CHUNK_REFS,
num_chunk_refs,
0,
);
}
#[inline]
pub fn add_extra(
&mut self,
extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ManifestFileInfoV2::VT_EXTRA,
extra,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ManifestFileInfoV2Builder<'a, 'b, A> {
let start = _fbb.start_table();
ManifestFileInfoV2Builder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ManifestFileInfoV2<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ManifestFileInfoV2<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ManifestFileInfoV2");
ds.field("id", &self.id());
ds.field("size_bytes", &self.size_bytes());
ds.field("num_chunk_refs", &self.num_chunk_refs());
ds.field("extra", &self.extra());
ds.finish()
}
}
pub enum ManifestRefOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ManifestRef<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ManifestRef<'a> {
type Inner = ManifestRef<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> ManifestRef<'a> {
pub const VT_OBJECT_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_EXTENTS: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ManifestRef { _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 ManifestRefArgs<'args>,
) -> ::flatbuffers::WIPOffset<ManifestRef<'bldr>> {
let mut builder = ManifestRefBuilder::new(_fbb);
if let Some(x) = args.extents {
builder.add_extents(x);
}
if let Some(x) = args.object_id {
builder.add_object_id(x);
}
builder.finish()
}
#[inline]
pub fn object_id(&self) -> &'a ObjectId12 {
unsafe {
self._tab.get::<ObjectId12>(ManifestRef::VT_OBJECT_ID, None).unwrap()
}
}
#[inline]
pub fn extents(&self) -> ::flatbuffers::Vector<'a, ChunkIndexRange> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'a, ChunkIndexRange>,
>>(ManifestRef::VT_EXTENTS, None)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for ManifestRef<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId12>("object_id", Self::VT_OBJECT_ID, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'_, ChunkIndexRange>,
>>("extents", Self::VT_EXTENTS, true)?
.finish();
Ok(())
}
}
pub struct ManifestRefArgs<'a> {
pub object_id: Option<&'a ObjectId12>,
pub extents:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ChunkIndexRange>>>,
}
impl<'a> Default for ManifestRefArgs<'a> {
#[inline]
fn default() -> Self {
ManifestRefArgs {
object_id: None, extents: None, }
}
}
pub struct ManifestRefBuilder<'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> ManifestRefBuilder<'a, 'b, A> {
#[inline]
pub fn add_object_id(&mut self, object_id: &ObjectId12) {
self.fbb_
.push_slot_always::<&ObjectId12>(ManifestRef::VT_OBJECT_ID, object_id);
}
#[inline]
pub fn add_extents(
&mut self,
extents: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, ChunkIndexRange>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ManifestRef::VT_EXTENTS,
extents,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ManifestRefBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ManifestRefBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ManifestRef<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, ManifestRef::VT_OBJECT_ID, "object_id");
self.fbb_.required(o, ManifestRef::VT_EXTENTS, "extents");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ManifestRef<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ManifestRef");
ds.field("object_id", &self.object_id());
ds.field("extents", &self.extents());
ds.finish()
}
}
pub enum DimensionShapeV2Offset {}
#[derive(Copy, Clone, PartialEq)]
pub struct DimensionShapeV2<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for DimensionShapeV2<'a> {
type Inner = DimensionShapeV2<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> DimensionShapeV2<'a> {
pub const VT_ARRAY_LENGTH: ::flatbuffers::VOffsetT = 4;
pub const VT_NUM_CHUNKS: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
DimensionShapeV2 { _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 DimensionShapeV2Args,
) -> ::flatbuffers::WIPOffset<DimensionShapeV2<'bldr>> {
let mut builder = DimensionShapeV2Builder::new(_fbb);
builder.add_array_length(args.array_length);
builder.add_num_chunks(args.num_chunks);
builder.finish()
}
#[inline]
pub fn array_length(&self) -> u64 {
unsafe {
self._tab.get::<u64>(DimensionShapeV2::VT_ARRAY_LENGTH, Some(0)).unwrap()
}
}
#[inline]
pub fn num_chunks(&self) -> u32 {
unsafe {
self._tab.get::<u32>(DimensionShapeV2::VT_NUM_CHUNKS, Some(0)).unwrap()
}
}
}
impl ::flatbuffers::Verifiable for DimensionShapeV2<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<u64>("array_length", Self::VT_ARRAY_LENGTH, false)?
.visit_field::<u32>("num_chunks", Self::VT_NUM_CHUNKS, false)?
.finish();
Ok(())
}
}
pub struct DimensionShapeV2Args {
pub array_length: u64,
pub num_chunks: u32,
}
impl<'a> Default for DimensionShapeV2Args {
#[inline]
fn default() -> Self {
DimensionShapeV2Args { array_length: 0, num_chunks: 0 }
}
}
pub struct DimensionShapeV2Builder<'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> DimensionShapeV2Builder<'a, 'b, A> {
#[inline]
pub fn add_array_length(&mut self, array_length: u64) {
self.fbb_.push_slot::<u64>(
DimensionShapeV2::VT_ARRAY_LENGTH,
array_length,
0,
);
}
#[inline]
pub fn add_num_chunks(&mut self, num_chunks: u32) {
self.fbb_.push_slot::<u32>(DimensionShapeV2::VT_NUM_CHUNKS, num_chunks, 0);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> DimensionShapeV2Builder<'a, 'b, A> {
let start = _fbb.start_table();
DimensionShapeV2Builder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<DimensionShapeV2<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for DimensionShapeV2<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("DimensionShapeV2");
ds.field("array_length", &self.array_length());
ds.field("num_chunks", &self.num_chunks());
ds.finish()
}
}
pub enum DimensionNameOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct DimensionName<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for DimensionName<'a> {
type Inner = DimensionName<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> DimensionName<'a> {
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
DimensionName { _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 DimensionNameArgs<'args>,
) -> ::flatbuffers::WIPOffset<DimensionName<'bldr>> {
let mut builder = DimensionNameBuilder::new(_fbb);
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>>(
DimensionName::VT_NAME,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for DimensionName<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"name",
Self::VT_NAME,
false,
)?
.finish();
Ok(())
}
}
pub struct DimensionNameArgs<'a> {
pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for DimensionNameArgs<'a> {
#[inline]
fn default() -> Self {
DimensionNameArgs { name: None }
}
}
pub struct DimensionNameBuilder<'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> DimensionNameBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
DimensionName::VT_NAME,
name,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> DimensionNameBuilder<'a, 'b, A> {
let start = _fbb.start_table();
DimensionNameBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<DimensionName<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for DimensionName<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("DimensionName");
ds.field("name", &self.name());
ds.finish()
}
}
pub enum GroupNodeDataOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct GroupNodeData<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for GroupNodeData<'a> {
type Inner = GroupNodeData<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> GroupNodeData<'a> {
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
GroupNodeData { _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 GroupNodeDataArgs,
) -> ::flatbuffers::WIPOffset<GroupNodeData<'bldr>> {
let mut builder = GroupNodeDataBuilder::new(_fbb);
builder.finish()
}
}
impl ::flatbuffers::Verifiable for GroupNodeData<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?.finish();
Ok(())
}
}
pub struct GroupNodeDataArgs {}
impl<'a> Default for GroupNodeDataArgs {
#[inline]
fn default() -> Self {
GroupNodeDataArgs {}
}
}
pub struct GroupNodeDataBuilder<'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> GroupNodeDataBuilder<'a, 'b, A> {
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> GroupNodeDataBuilder<'a, 'b, A> {
let start = _fbb.start_table();
GroupNodeDataBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<GroupNodeData<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for GroupNodeData<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("GroupNodeData");
ds.finish()
}
}
pub enum ArrayNodeDataOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ArrayNodeData<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ArrayNodeData<'a> {
type Inner = ArrayNodeData<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> ArrayNodeData<'a> {
pub const VT_SHAPE: ::flatbuffers::VOffsetT = 4;
pub const VT_DIMENSION_NAMES: ::flatbuffers::VOffsetT = 6;
pub const VT_MANIFESTS: ::flatbuffers::VOffsetT = 8;
pub const VT_SHAPE_V2: ::flatbuffers::VOffsetT = 10;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ArrayNodeData { _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 ArrayNodeDataArgs<'args>,
) -> ::flatbuffers::WIPOffset<ArrayNodeData<'bldr>> {
let mut builder = ArrayNodeDataBuilder::new(_fbb);
if let Some(x) = args.shape_v2 {
builder.add_shape_v2(x);
}
if let Some(x) = args.manifests {
builder.add_manifests(x);
}
if let Some(x) = args.dimension_names {
builder.add_dimension_names(x);
}
if let Some(x) = args.shape {
builder.add_shape(x);
}
builder.finish()
}
#[inline]
pub fn shape(&self) -> ::flatbuffers::Vector<'a, DimensionShape> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'a, DimensionShape>,
>>(ArrayNodeData::VT_SHAPE, None)
.unwrap()
}
}
#[inline]
pub fn dimension_names(
&self,
) -> Option<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<DimensionName<'a>>>,
> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<DimensionName>,
>,
>>(ArrayNodeData::VT_DIMENSION_NAMES, None)
}
}
#[inline]
pub fn manifests(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ManifestRef<'a>>>
{
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ManifestRef>,
>,
>>(ArrayNodeData::VT_MANIFESTS, None)
.unwrap()
}
}
#[inline]
pub fn shape_v2(
&self,
) -> Option<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<DimensionShapeV2<'a>>,
>,
> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<DimensionShapeV2>,
>,
>>(ArrayNodeData::VT_SHAPE_V2, None)
}
}
}
impl ::flatbuffers::Verifiable for ArrayNodeData<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, DimensionShape>>>("shape", Self::VT_SHAPE, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<DimensionName>>>>("dimension_names", Self::VT_DIMENSION_NAMES, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ManifestRef>>>>("manifests", Self::VT_MANIFESTS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<DimensionShapeV2>>>>("shape_v2", Self::VT_SHAPE_V2, false)?
.finish();
Ok(())
}
}
pub struct ArrayNodeDataArgs<'a> {
pub shape:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, DimensionShape>>>,
pub dimension_names: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<DimensionName<'a>>,
>,
>,
>,
pub manifests: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ManifestRef<'a>>,
>,
>,
>,
pub shape_v2: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<DimensionShapeV2<'a>>,
>,
>,
>,
}
impl<'a> Default for ArrayNodeDataArgs<'a> {
#[inline]
fn default() -> Self {
ArrayNodeDataArgs {
shape: None, dimension_names: None,
manifests: None, shape_v2: None,
}
}
}
pub struct ArrayNodeDataBuilder<'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> ArrayNodeDataBuilder<'a, 'b, A> {
#[inline]
pub fn add_shape(
&mut self,
shape: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, DimensionShape>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ArrayNodeData::VT_SHAPE,
shape,
);
}
#[inline]
pub fn add_dimension_names(
&mut self,
dimension_names: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<DimensionName<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ArrayNodeData::VT_DIMENSION_NAMES,
dimension_names,
);
}
#[inline]
pub fn add_manifests(
&mut self,
manifests: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<ManifestRef<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ArrayNodeData::VT_MANIFESTS,
manifests,
);
}
#[inline]
pub fn add_shape_v2(
&mut self,
shape_v2: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<DimensionShapeV2<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ArrayNodeData::VT_SHAPE_V2,
shape_v2,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ArrayNodeDataBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ArrayNodeDataBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ArrayNodeData<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, ArrayNodeData::VT_SHAPE, "shape");
self.fbb_.required(o, ArrayNodeData::VT_MANIFESTS, "manifests");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ArrayNodeData<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ArrayNodeData");
ds.field("shape", &self.shape());
ds.field("dimension_names", &self.dimension_names());
ds.field("manifests", &self.manifests());
ds.field("shape_v2", &self.shape_v2());
ds.finish()
}
}
pub enum NodeSnapshotOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct NodeSnapshot<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for NodeSnapshot<'a> {
type Inner = NodeSnapshot<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> NodeSnapshot<'a> {
pub const VT_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_PATH: ::flatbuffers::VOffsetT = 6;
pub const VT_USER_DATA: ::flatbuffers::VOffsetT = 8;
pub const VT_NODE_DATA_TYPE: ::flatbuffers::VOffsetT = 10;
pub const VT_NODE_DATA: ::flatbuffers::VOffsetT = 12;
pub const VT_EXTRA: ::flatbuffers::VOffsetT = 14;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
NodeSnapshot { _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 NodeSnapshotArgs<'args>,
) -> ::flatbuffers::WIPOffset<NodeSnapshot<'bldr>> {
let mut builder = NodeSnapshotBuilder::new(_fbb);
if let Some(x) = args.extra {
builder.add_extra(x);
}
if let Some(x) = args.node_data {
builder.add_node_data(x);
}
if let Some(x) = args.user_data {
builder.add_user_data(x);
}
if let Some(x) = args.path {
builder.add_path(x);
}
if let Some(x) = args.id {
builder.add_id(x);
}
builder.add_node_data_type(args.node_data_type);
builder.finish()
}
#[inline]
pub fn id(&self) -> &'a ObjectId8 {
unsafe { self._tab.get::<ObjectId8>(NodeSnapshot::VT_ID, None).unwrap() }
}
#[inline]
pub fn path(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
NodeSnapshot::VT_PATH,
None,
)
.unwrap()
}
}
#[inline]
pub fn user_data(&self) -> ::flatbuffers::Vector<'a, u8> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
NodeSnapshot::VT_USER_DATA,
None,
)
.unwrap()
}
}
#[inline]
pub fn node_data_type(&self) -> NodeData {
unsafe {
self._tab
.get::<NodeData>(
NodeSnapshot::VT_NODE_DATA_TYPE,
Some(NodeData::NONE),
)
.unwrap()
}
}
#[inline]
pub fn node_data(&self) -> ::flatbuffers::Table<'a> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
NodeSnapshot::VT_NODE_DATA,
None,
)
.unwrap()
}
}
#[inline]
pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
NodeSnapshot::VT_EXTRA,
None,
)
}
}
#[inline]
#[allow(non_snake_case)]
pub fn node_data_as_array(&self) -> Option<ArrayNodeData<'a>> {
if self.node_data_type() == NodeData::Array {
let u = self.node_data();
Some(unsafe { ArrayNodeData::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn node_data_as_group(&self) -> Option<GroupNodeData<'a>> {
if self.node_data_type() == NodeData::Group {
let u = self.node_data();
Some(unsafe { GroupNodeData::init_from_table(u) })
} else {
None
}
}
}
impl ::flatbuffers::Verifiable for NodeSnapshot<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId8>("id", Self::VT_ID, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("path", Self::VT_PATH, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("user_data", Self::VT_USER_DATA, true)?
.visit_union::<NodeData, _>("node_data_type", Self::VT_NODE_DATA_TYPE, "node_data", Self::VT_NODE_DATA, true, |key, v, pos| {
match key {
NodeData::Array => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ArrayNodeData>>("NodeData::Array", pos),
NodeData::Group => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GroupNodeData>>("NodeData::Group", pos),
_ => Ok(()),
}
})?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("extra", Self::VT_EXTRA, false)?
.finish();
Ok(())
}
}
pub struct NodeSnapshotArgs<'a> {
pub id: Option<&'a ObjectId8>,
pub path: Option<::flatbuffers::WIPOffset<&'a str>>,
pub user_data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
pub node_data_type: NodeData,
pub node_data: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for NodeSnapshotArgs<'a> {
#[inline]
fn default() -> Self {
NodeSnapshotArgs {
id: None, path: None, user_data: None, node_data_type: NodeData::NONE,
node_data: None, extra: None,
}
}
}
pub struct NodeSnapshotBuilder<'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> NodeSnapshotBuilder<'a, 'b, A> {
#[inline]
pub fn add_id(&mut self, id: &ObjectId8) {
self.fbb_.push_slot_always::<&ObjectId8>(NodeSnapshot::VT_ID, id);
}
#[inline]
pub fn add_path(&mut self, path: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
NodeSnapshot::VT_PATH,
path,
);
}
#[inline]
pub fn add_user_data(
&mut self,
user_data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
NodeSnapshot::VT_USER_DATA,
user_data,
);
}
#[inline]
pub fn add_node_data_type(&mut self, node_data_type: NodeData) {
self.fbb_.push_slot::<NodeData>(
NodeSnapshot::VT_NODE_DATA_TYPE,
node_data_type,
NodeData::NONE,
);
}
#[inline]
pub fn add_node_data(
&mut self,
node_data: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
NodeSnapshot::VT_NODE_DATA,
node_data,
);
}
#[inline]
pub fn add_extra(
&mut self,
extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
NodeSnapshot::VT_EXTRA,
extra,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> NodeSnapshotBuilder<'a, 'b, A> {
let start = _fbb.start_table();
NodeSnapshotBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<NodeSnapshot<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, NodeSnapshot::VT_ID, "id");
self.fbb_.required(o, NodeSnapshot::VT_PATH, "path");
self.fbb_.required(o, NodeSnapshot::VT_USER_DATA, "user_data");
self.fbb_.required(o, NodeSnapshot::VT_NODE_DATA, "node_data");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for NodeSnapshot<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("NodeSnapshot");
ds.field("id", &self.id());
ds.field("path", &self.path());
ds.field("user_data", &self.user_data());
ds.field("node_data_type", &self.node_data_type());
match self.node_data_type() {
NodeData::Array => {
if let Some(x) = self.node_data_as_array() {
ds.field("node_data", &x)
} else {
ds.field("node_data", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
NodeData::Group => {
if let Some(x) = self.node_data_as_group() {
ds.field("node_data", &x)
} else {
ds.field("node_data", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
_ => {
let x: Option<()> = None;
ds.field("node_data", &x)
}
};
ds.field("extra", &self.extra());
ds.finish()
}
}
pub enum SnapshotOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Snapshot<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for Snapshot<'a> {
type Inner = Snapshot<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> Snapshot<'a> {
pub const VT_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_PARENT_ID: ::flatbuffers::VOffsetT = 6;
pub const VT_NODES: ::flatbuffers::VOffsetT = 8;
pub const VT_FLUSHED_AT: ::flatbuffers::VOffsetT = 10;
pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 12;
pub const VT_METADATA: ::flatbuffers::VOffsetT = 14;
pub const VT_MANIFEST_FILES: ::flatbuffers::VOffsetT = 16;
pub const VT_MANIFEST_FILES_V2: ::flatbuffers::VOffsetT = 18;
pub const VT_EXTRA: ::flatbuffers::VOffsetT = 20;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
Snapshot { _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 SnapshotArgs<'args>,
) -> ::flatbuffers::WIPOffset<Snapshot<'bldr>> {
let mut builder = SnapshotBuilder::new(_fbb);
builder.add_flushed_at(args.flushed_at);
if let Some(x) = args.extra {
builder.add_extra(x);
}
if let Some(x) = args.manifest_files_v2 {
builder.add_manifest_files_v2(x);
}
if let Some(x) = args.manifest_files {
builder.add_manifest_files(x);
}
if let Some(x) = args.metadata {
builder.add_metadata(x);
}
if let Some(x) = args.message {
builder.add_message(x);
}
if let Some(x) = args.nodes {
builder.add_nodes(x);
}
if let Some(x) = args.parent_id {
builder.add_parent_id(x);
}
if let Some(x) = args.id {
builder.add_id(x);
}
builder.finish()
}
#[inline]
pub fn id(&self) -> &'a ObjectId12 {
unsafe { self._tab.get::<ObjectId12>(Snapshot::VT_ID, None).unwrap() }
}
#[inline]
pub fn parent_id(&self) -> Option<&'a ObjectId12> {
unsafe { self._tab.get::<ObjectId12>(Snapshot::VT_PARENT_ID, None) }
}
#[inline]
pub fn nodes(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<NodeSnapshot<'a>>>
{
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<NodeSnapshot>,
>,
>>(Snapshot::VT_NODES, None)
.unwrap()
}
}
#[inline]
pub fn flushed_at(&self) -> u64 {
unsafe { self._tab.get::<u64>(Snapshot::VT_FLUSHED_AT, Some(0)).unwrap() }
}
#[inline]
pub fn message(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
Snapshot::VT_MESSAGE,
None,
)
.unwrap()
}
}
#[inline]
pub fn metadata(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MetadataItem<'a>>>
{
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<MetadataItem>,
>,
>>(Snapshot::VT_METADATA, None)
.unwrap()
}
}
#[inline]
pub fn manifest_files(&self) -> ::flatbuffers::Vector<'a, ManifestFileInfo> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'a, ManifestFileInfo>,
>>(Snapshot::VT_MANIFEST_FILES, None)
.unwrap()
}
}
#[inline]
pub fn manifest_files_v2(
&self,
) -> Option<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ManifestFileInfoV2<'a>>,
>,
> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ManifestFileInfoV2>,
>,
>>(Snapshot::VT_MANIFEST_FILES_V2, None)
}
}
#[inline]
pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
Snapshot::VT_EXTRA,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for Snapshot<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId12>("id", Self::VT_ID, true)?
.visit_field::<ObjectId12>("parent_id", Self::VT_PARENT_ID, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<NodeSnapshot>>>>("nodes", Self::VT_NODES, true)?
.visit_field::<u64>("flushed_at", Self::VT_FLUSHED_AT, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("message", Self::VT_MESSAGE, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<MetadataItem>>>>("metadata", Self::VT_METADATA, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ManifestFileInfo>>>("manifest_files", Self::VT_MANIFEST_FILES, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ManifestFileInfoV2>>>>("manifest_files_v2", Self::VT_MANIFEST_FILES_V2, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("extra", Self::VT_EXTRA, false)?
.finish();
Ok(())
}
}
pub struct SnapshotArgs<'a> {
pub id: Option<&'a ObjectId12>,
pub parent_id: Option<&'a ObjectId12>,
pub nodes: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<NodeSnapshot<'a>>,
>,
>,
>,
pub flushed_at: u64,
pub message: Option<::flatbuffers::WIPOffset<&'a str>>,
pub metadata: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<MetadataItem<'a>>,
>,
>,
>,
pub manifest_files:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ManifestFileInfo>>>,
pub manifest_files_v2: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ManifestFileInfoV2<'a>>,
>,
>,
>,
pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for SnapshotArgs<'a> {
#[inline]
fn default() -> Self {
SnapshotArgs {
id: None, parent_id: None,
nodes: None, flushed_at: 0,
message: None, metadata: None, manifest_files: None, manifest_files_v2: None,
extra: None,
}
}
}
pub struct SnapshotBuilder<'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> SnapshotBuilder<'a, 'b, A> {
#[inline]
pub fn add_id(&mut self, id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(Snapshot::VT_ID, id);
}
#[inline]
pub fn add_parent_id(&mut self, parent_id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(Snapshot::VT_PARENT_ID, parent_id);
}
#[inline]
pub fn add_nodes(
&mut self,
nodes: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<NodeSnapshot<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Snapshot::VT_NODES,
nodes,
);
}
#[inline]
pub fn add_flushed_at(&mut self, flushed_at: u64) {
self.fbb_.push_slot::<u64>(Snapshot::VT_FLUSHED_AT, flushed_at, 0);
}
#[inline]
pub fn add_message(&mut self, message: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Snapshot::VT_MESSAGE,
message,
);
}
#[inline]
pub fn add_metadata(
&mut self,
metadata: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<MetadataItem<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Snapshot::VT_METADATA,
metadata,
);
}
#[inline]
pub fn add_manifest_files(
&mut self,
manifest_files: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ManifestFileInfo>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Snapshot::VT_MANIFEST_FILES,
manifest_files,
);
}
#[inline]
pub fn add_manifest_files_v2(
&mut self,
manifest_files_v2: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<ManifestFileInfoV2<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Snapshot::VT_MANIFEST_FILES_V2,
manifest_files_v2,
);
}
#[inline]
pub fn add_extra(
&mut self,
extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Snapshot::VT_EXTRA,
extra,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> SnapshotBuilder<'a, 'b, A> {
let start = _fbb.start_table();
SnapshotBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<Snapshot<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, Snapshot::VT_ID, "id");
self.fbb_.required(o, Snapshot::VT_NODES, "nodes");
self.fbb_.required(o, Snapshot::VT_MESSAGE, "message");
self.fbb_.required(o, Snapshot::VT_METADATA, "metadata");
self.fbb_.required(o, Snapshot::VT_MANIFEST_FILES, "manifest_files");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for Snapshot<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("Snapshot");
ds.field("id", &self.id());
ds.field("parent_id", &self.parent_id());
ds.field("nodes", &self.nodes());
ds.field("flushed_at", &self.flushed_at());
ds.field("message", &self.message());
ds.field("metadata", &self.metadata());
ds.field("manifest_files", &self.manifest_files());
ds.field("manifest_files_v2", &self.manifest_files_v2());
ds.field("extra", &self.extra());
ds.finish()
}
}
pub enum ChunkIndicesOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ChunkIndices<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ChunkIndices<'a> {
type Inner = ChunkIndices<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> ChunkIndices<'a> {
pub const VT_COORDS: ::flatbuffers::VOffsetT = 4;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ChunkIndices { _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 ChunkIndicesArgs<'args>,
) -> ::flatbuffers::WIPOffset<ChunkIndices<'bldr>> {
let mut builder = ChunkIndicesBuilder::new(_fbb);
if let Some(x) = args.coords {
builder.add_coords(x);
}
builder.finish()
}
#[inline]
pub fn coords(&self) -> ::flatbuffers::Vector<'a, u32> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u32>>>(ChunkIndices::VT_COORDS, None).unwrap()
}
}
}
impl ::flatbuffers::Verifiable for ChunkIndices<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u32>>>("coords", Self::VT_COORDS, true)?
.finish();
Ok(())
}
}
pub struct ChunkIndicesArgs<'a> {
pub coords: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u32>>>,
}
impl<'a> Default for ChunkIndicesArgs<'a> {
#[inline]
fn default() -> Self {
ChunkIndicesArgs {
coords: None, }
}
}
pub struct ChunkIndicesBuilder<'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> ChunkIndicesBuilder<'a, 'b, A> {
#[inline]
pub fn add_coords(
&mut self,
coords: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u32>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ChunkIndices::VT_COORDS,
coords,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ChunkIndicesBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ChunkIndicesBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ChunkIndices<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, ChunkIndices::VT_COORDS, "coords");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ChunkIndices<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ChunkIndices");
ds.field("coords", &self.coords());
ds.finish()
}
}
pub enum ArrayUpdatedChunksOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ArrayUpdatedChunks<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ArrayUpdatedChunks<'a> {
type Inner = ArrayUpdatedChunks<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> ArrayUpdatedChunks<'a> {
pub const VT_NODE_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_CHUNKS: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ArrayUpdatedChunks { _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 ArrayUpdatedChunksArgs<'args>,
) -> ::flatbuffers::WIPOffset<ArrayUpdatedChunks<'bldr>> {
let mut builder = ArrayUpdatedChunksBuilder::new(_fbb);
if let Some(x) = args.chunks {
builder.add_chunks(x);
}
if let Some(x) = args.node_id {
builder.add_node_id(x);
}
builder.finish()
}
#[inline]
pub fn node_id(&self) -> &'a ObjectId8 {
unsafe {
self._tab.get::<ObjectId8>(ArrayUpdatedChunks::VT_NODE_ID, None).unwrap()
}
}
#[inline]
pub fn chunks(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ChunkIndices<'a>>>
{
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ChunkIndices>,
>,
>>(ArrayUpdatedChunks::VT_CHUNKS, None)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for ArrayUpdatedChunks<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId8>("node_id", Self::VT_NODE_ID, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'_,
::flatbuffers::ForwardsUOffset<ChunkIndices>,
>,
>>("chunks", Self::VT_CHUNKS, true)?
.finish();
Ok(())
}
}
pub struct ArrayUpdatedChunksArgs<'a> {
pub node_id: Option<&'a ObjectId8>,
pub chunks: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ChunkIndices<'a>>,
>,
>,
>,
}
impl<'a> Default for ArrayUpdatedChunksArgs<'a> {
#[inline]
fn default() -> Self {
ArrayUpdatedChunksArgs {
node_id: None, chunks: None, }
}
}
pub struct ArrayUpdatedChunksBuilder<'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> ArrayUpdatedChunksBuilder<'a, 'b, A> {
#[inline]
pub fn add_node_id(&mut self, node_id: &ObjectId8) {
self.fbb_
.push_slot_always::<&ObjectId8>(ArrayUpdatedChunks::VT_NODE_ID, node_id);
}
#[inline]
pub fn add_chunks(
&mut self,
chunks: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<ChunkIndices<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ArrayUpdatedChunks::VT_CHUNKS,
chunks,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ArrayUpdatedChunksBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ArrayUpdatedChunksBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ArrayUpdatedChunks<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, ArrayUpdatedChunks::VT_NODE_ID, "node_id");
self.fbb_.required(o, ArrayUpdatedChunks::VT_CHUNKS, "chunks");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ArrayUpdatedChunks<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ArrayUpdatedChunks");
ds.field("node_id", &self.node_id());
ds.field("chunks", &self.chunks());
ds.finish()
}
}
pub enum MoveOperationOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct MoveOperation<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for MoveOperation<'a> {
type Inner = MoveOperation<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> MoveOperation<'a> {
pub const VT_FROM: ::flatbuffers::VOffsetT = 4;
pub const VT_TO: ::flatbuffers::VOffsetT = 6;
pub const VT_NODE_ID: ::flatbuffers::VOffsetT = 8;
pub const VT_NODE_TYPE: ::flatbuffers::VOffsetT = 10;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
MoveOperation { _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 MoveOperationArgs<'args>,
) -> ::flatbuffers::WIPOffset<MoveOperation<'bldr>> {
let mut builder = MoveOperationBuilder::new(_fbb);
if let Some(x) = args.node_id {
builder.add_node_id(x);
}
if let Some(x) = args.to {
builder.add_to(x);
}
if let Some(x) = args.from {
builder.add_from(x);
}
builder.add_node_type(args.node_type);
builder.finish()
}
#[inline]
pub fn from(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
MoveOperation::VT_FROM,
None,
)
}
}
#[inline]
pub fn to(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
MoveOperation::VT_TO,
None,
)
}
}
#[inline]
pub fn node_id(&self) -> Option<&'a ObjectId8> {
unsafe { self._tab.get::<ObjectId8>(MoveOperation::VT_NODE_ID, None) }
}
#[inline]
pub fn node_type(&self) -> NodeType {
unsafe {
self._tab
.get::<NodeType>(MoveOperation::VT_NODE_TYPE, Some(NodeType::Group))
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for MoveOperation<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"from",
Self::VT_FROM,
false,
)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"to",
Self::VT_TO,
false,
)?
.visit_field::<ObjectId8>("node_id", Self::VT_NODE_ID, false)?
.visit_field::<NodeType>("node_type", Self::VT_NODE_TYPE, false)?
.finish();
Ok(())
}
}
pub struct MoveOperationArgs<'a> {
pub from: Option<::flatbuffers::WIPOffset<&'a str>>,
pub to: Option<::flatbuffers::WIPOffset<&'a str>>,
pub node_id: Option<&'a ObjectId8>,
pub node_type: NodeType,
}
impl<'a> Default for MoveOperationArgs<'a> {
#[inline]
fn default() -> Self {
MoveOperationArgs {
from: None,
to: None,
node_id: None,
node_type: NodeType::Group,
}
}
}
pub struct MoveOperationBuilder<'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> MoveOperationBuilder<'a, 'b, A> {
#[inline]
pub fn add_from(&mut self, from: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
MoveOperation::VT_FROM,
from,
);
}
#[inline]
pub fn add_to(&mut self, to: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
MoveOperation::VT_TO,
to,
);
}
#[inline]
pub fn add_node_id(&mut self, node_id: &ObjectId8) {
self.fbb_.push_slot_always::<&ObjectId8>(MoveOperation::VT_NODE_ID, node_id);
}
#[inline]
pub fn add_node_type(&mut self, node_type: NodeType) {
self.fbb_.push_slot::<NodeType>(
MoveOperation::VT_NODE_TYPE,
node_type,
NodeType::Group,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> MoveOperationBuilder<'a, 'b, A> {
let start = _fbb.start_table();
MoveOperationBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<MoveOperation<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for MoveOperation<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("MoveOperation");
ds.field("from", &self.from());
ds.field("to", &self.to());
ds.field("node_id", &self.node_id());
ds.field("node_type", &self.node_type());
ds.finish()
}
}
pub enum TransactionLogOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct TransactionLog<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for TransactionLog<'a> {
type Inner = TransactionLog<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> TransactionLog<'a> {
pub const VT_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_NEW_GROUPS: ::flatbuffers::VOffsetT = 6;
pub const VT_NEW_ARRAYS: ::flatbuffers::VOffsetT = 8;
pub const VT_DELETED_GROUPS: ::flatbuffers::VOffsetT = 10;
pub const VT_DELETED_ARRAYS: ::flatbuffers::VOffsetT = 12;
pub const VT_UPDATED_ARRAYS: ::flatbuffers::VOffsetT = 14;
pub const VT_UPDATED_GROUPS: ::flatbuffers::VOffsetT = 16;
pub const VT_UPDATED_CHUNKS: ::flatbuffers::VOffsetT = 18;
pub const VT_MOVED_NODES: ::flatbuffers::VOffsetT = 20;
pub const VT_EXTRA: ::flatbuffers::VOffsetT = 22;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
TransactionLog { _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 TransactionLogArgs<'args>,
) -> ::flatbuffers::WIPOffset<TransactionLog<'bldr>> {
let mut builder = TransactionLogBuilder::new(_fbb);
if let Some(x) = args.extra {
builder.add_extra(x);
}
if let Some(x) = args.moved_nodes {
builder.add_moved_nodes(x);
}
if let Some(x) = args.updated_chunks {
builder.add_updated_chunks(x);
}
if let Some(x) = args.updated_groups {
builder.add_updated_groups(x);
}
if let Some(x) = args.updated_arrays {
builder.add_updated_arrays(x);
}
if let Some(x) = args.deleted_arrays {
builder.add_deleted_arrays(x);
}
if let Some(x) = args.deleted_groups {
builder.add_deleted_groups(x);
}
if let Some(x) = args.new_arrays {
builder.add_new_arrays(x);
}
if let Some(x) = args.new_groups {
builder.add_new_groups(x);
}
if let Some(x) = args.id {
builder.add_id(x);
}
builder.finish()
}
#[inline]
pub fn id(&self) -> &'a ObjectId12 {
unsafe { self._tab.get::<ObjectId12>(TransactionLog::VT_ID, None).unwrap() }
}
#[inline]
pub fn new_groups(&self) -> ::flatbuffers::Vector<'a, ObjectId8> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ObjectId8>>>(TransactionLog::VT_NEW_GROUPS, None).unwrap()
}
}
#[inline]
pub fn new_arrays(&self) -> ::flatbuffers::Vector<'a, ObjectId8> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ObjectId8>>>(TransactionLog::VT_NEW_ARRAYS, None).unwrap()
}
}
#[inline]
pub fn deleted_groups(&self) -> ::flatbuffers::Vector<'a, ObjectId8> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ObjectId8>>>(TransactionLog::VT_DELETED_GROUPS, None).unwrap()
}
}
#[inline]
pub fn deleted_arrays(&self) -> ::flatbuffers::Vector<'a, ObjectId8> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ObjectId8>>>(TransactionLog::VT_DELETED_ARRAYS, None).unwrap()
}
}
#[inline]
pub fn updated_arrays(&self) -> ::flatbuffers::Vector<'a, ObjectId8> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ObjectId8>>>(TransactionLog::VT_UPDATED_ARRAYS, None).unwrap()
}
}
#[inline]
pub fn updated_groups(&self) -> ::flatbuffers::Vector<'a, ObjectId8> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ObjectId8>>>(TransactionLog::VT_UPDATED_GROUPS, None).unwrap()
}
}
#[inline]
pub fn updated_chunks(
&self,
) -> ::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ArrayUpdatedChunks<'a>>,
> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ArrayUpdatedChunks>,
>,
>>(TransactionLog::VT_UPDATED_CHUNKS, None)
.unwrap()
}
}
#[inline]
pub fn moved_nodes(
&self,
) -> Option<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MoveOperation<'a>>>,
> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<MoveOperation>,
>,
>>(TransactionLog::VT_MOVED_NODES, None)
}
}
#[inline]
pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
TransactionLog::VT_EXTRA,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for TransactionLog<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId12>("id", Self::VT_ID, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ObjectId8>>>("new_groups", Self::VT_NEW_GROUPS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ObjectId8>>>("new_arrays", Self::VT_NEW_ARRAYS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ObjectId8>>>("deleted_groups", Self::VT_DELETED_GROUPS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ObjectId8>>>("deleted_arrays", Self::VT_DELETED_ARRAYS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ObjectId8>>>("updated_arrays", Self::VT_UPDATED_ARRAYS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ObjectId8>>>("updated_groups", Self::VT_UPDATED_GROUPS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ArrayUpdatedChunks>>>>("updated_chunks", Self::VT_UPDATED_CHUNKS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<MoveOperation>>>>("moved_nodes", Self::VT_MOVED_NODES, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("extra", Self::VT_EXTRA, false)?
.finish();
Ok(())
}
}
pub struct TransactionLogArgs<'a> {
pub id: Option<&'a ObjectId12>,
pub new_groups:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ObjectId8>>>,
pub new_arrays:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ObjectId8>>>,
pub deleted_groups:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ObjectId8>>>,
pub deleted_arrays:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ObjectId8>>>,
pub updated_arrays:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ObjectId8>>>,
pub updated_groups:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ObjectId8>>>,
pub updated_chunks: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<ArrayUpdatedChunks<'a>>,
>,
>,
>,
pub moved_nodes: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<MoveOperation<'a>>,
>,
>,
>,
pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for TransactionLogArgs<'a> {
#[inline]
fn default() -> Self {
TransactionLogArgs {
id: None, new_groups: None, new_arrays: None, deleted_groups: None, deleted_arrays: None, updated_arrays: None, updated_groups: None, updated_chunks: None, moved_nodes: None,
extra: None,
}
}
}
pub struct TransactionLogBuilder<'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> TransactionLogBuilder<'a, 'b, A> {
#[inline]
pub fn add_id(&mut self, id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(TransactionLog::VT_ID, id);
}
#[inline]
pub fn add_new_groups(
&mut self,
new_groups: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, ObjectId8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TransactionLog::VT_NEW_GROUPS,
new_groups,
);
}
#[inline]
pub fn add_new_arrays(
&mut self,
new_arrays: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, ObjectId8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TransactionLog::VT_NEW_ARRAYS,
new_arrays,
);
}
#[inline]
pub fn add_deleted_groups(
&mut self,
deleted_groups: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ObjectId8>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TransactionLog::VT_DELETED_GROUPS,
deleted_groups,
);
}
#[inline]
pub fn add_deleted_arrays(
&mut self,
deleted_arrays: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ObjectId8>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TransactionLog::VT_DELETED_ARRAYS,
deleted_arrays,
);
}
#[inline]
pub fn add_updated_arrays(
&mut self,
updated_arrays: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ObjectId8>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TransactionLog::VT_UPDATED_ARRAYS,
updated_arrays,
);
}
#[inline]
pub fn add_updated_groups(
&mut self,
updated_groups: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ObjectId8>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TransactionLog::VT_UPDATED_GROUPS,
updated_groups,
);
}
#[inline]
pub fn add_updated_chunks(
&mut self,
updated_chunks: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<ArrayUpdatedChunks<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TransactionLog::VT_UPDATED_CHUNKS,
updated_chunks,
);
}
#[inline]
pub fn add_moved_nodes(
&mut self,
moved_nodes: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<MoveOperation<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TransactionLog::VT_MOVED_NODES,
moved_nodes,
);
}
#[inline]
pub fn add_extra(
&mut self,
extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TransactionLog::VT_EXTRA,
extra,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> TransactionLogBuilder<'a, 'b, A> {
let start = _fbb.start_table();
TransactionLogBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<TransactionLog<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, TransactionLog::VT_ID, "id");
self.fbb_.required(o, TransactionLog::VT_NEW_GROUPS, "new_groups");
self.fbb_.required(o, TransactionLog::VT_NEW_ARRAYS, "new_arrays");
self.fbb_.required(o, TransactionLog::VT_DELETED_GROUPS, "deleted_groups");
self.fbb_.required(o, TransactionLog::VT_DELETED_ARRAYS, "deleted_arrays");
self.fbb_.required(o, TransactionLog::VT_UPDATED_ARRAYS, "updated_arrays");
self.fbb_.required(o, TransactionLog::VT_UPDATED_GROUPS, "updated_groups");
self.fbb_.required(o, TransactionLog::VT_UPDATED_CHUNKS, "updated_chunks");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for TransactionLog<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("TransactionLog");
ds.field("id", &self.id());
ds.field("new_groups", &self.new_groups());
ds.field("new_arrays", &self.new_arrays());
ds.field("deleted_groups", &self.deleted_groups());
ds.field("deleted_arrays", &self.deleted_arrays());
ds.field("updated_arrays", &self.updated_arrays());
ds.field("updated_groups", &self.updated_groups());
ds.field("updated_chunks", &self.updated_chunks());
ds.field("moved_nodes", &self.moved_nodes());
ds.field("extra", &self.extra());
ds.finish()
}
}
pub enum RefOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Ref<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for Ref<'a> {
type Inner = Ref<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> Ref<'a> {
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
pub const VT_SNAPSHOT_INDEX: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
Ref { _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 RefArgs<'args>,
) -> ::flatbuffers::WIPOffset<Ref<'bldr>> {
let mut builder = RefBuilder::new(_fbb);
builder.add_snapshot_index(args.snapshot_index);
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(Ref::VT_NAME, None)
.unwrap()
}
}
#[inline]
pub fn snapshot_index(&self) -> u32 {
unsafe { self._tab.get::<u32>(Ref::VT_SNAPSHOT_INDEX, Some(0)).unwrap() }
}
}
impl ::flatbuffers::Verifiable for Ref<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"name",
Self::VT_NAME,
true,
)?
.visit_field::<u32>("snapshot_index", Self::VT_SNAPSHOT_INDEX, false)?
.finish();
Ok(())
}
}
pub struct RefArgs<'a> {
pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
pub snapshot_index: u32,
}
impl<'a> Default for RefArgs<'a> {
#[inline]
fn default() -> Self {
RefArgs {
name: None, snapshot_index: 0,
}
}
}
pub struct RefBuilder<'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> RefBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Ref::VT_NAME, name);
}
#[inline]
pub fn add_snapshot_index(&mut self, snapshot_index: u32) {
self.fbb_.push_slot::<u32>(Ref::VT_SNAPSHOT_INDEX, snapshot_index, 0);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> RefBuilder<'a, 'b, A> {
let start = _fbb.start_table();
RefBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<Ref<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, Ref::VT_NAME, "name");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for Ref<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("Ref");
ds.field("name", &self.name());
ds.field("snapshot_index", &self.snapshot_index());
ds.finish()
}
}
pub enum SnapshotInfoOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct SnapshotInfo<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for SnapshotInfo<'a> {
type Inner = SnapshotInfo<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> SnapshotInfo<'a> {
pub const VT_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_PARENT_OFFSET: ::flatbuffers::VOffsetT = 6;
pub const VT_FLUSHED_AT: ::flatbuffers::VOffsetT = 8;
pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 10;
pub const VT_METADATA: ::flatbuffers::VOffsetT = 12;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
SnapshotInfo { _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 SnapshotInfoArgs<'args>,
) -> ::flatbuffers::WIPOffset<SnapshotInfo<'bldr>> {
let mut builder = SnapshotInfoBuilder::new(_fbb);
builder.add_flushed_at(args.flushed_at);
if let Some(x) = args.metadata {
builder.add_metadata(x);
}
if let Some(x) = args.message {
builder.add_message(x);
}
builder.add_parent_offset(args.parent_offset);
if let Some(x) = args.id {
builder.add_id(x);
}
builder.finish()
}
#[inline]
pub fn id(&self) -> &'a ObjectId12 {
unsafe { self._tab.get::<ObjectId12>(SnapshotInfo::VT_ID, None).unwrap() }
}
#[inline]
pub fn parent_offset(&self) -> i32 {
unsafe {
self._tab.get::<i32>(SnapshotInfo::VT_PARENT_OFFSET, Some(0)).unwrap()
}
}
#[inline]
pub fn flushed_at(&self) -> u64 {
unsafe { self._tab.get::<u64>(SnapshotInfo::VT_FLUSHED_AT, Some(0)).unwrap() }
}
#[inline]
pub fn message(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
SnapshotInfo::VT_MESSAGE,
None,
)
.unwrap()
}
}
#[inline]
pub fn metadata(
&self,
) -> Option<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MetadataItem<'a>>>,
> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<MetadataItem>,
>,
>>(SnapshotInfo::VT_METADATA, None)
}
}
}
impl ::flatbuffers::Verifiable for SnapshotInfo<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId12>("id", Self::VT_ID, true)?
.visit_field::<i32>("parent_offset", Self::VT_PARENT_OFFSET, false)?
.visit_field::<u64>("flushed_at", Self::VT_FLUSHED_AT, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"message",
Self::VT_MESSAGE,
true,
)?
.visit_field::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'_,
::flatbuffers::ForwardsUOffset<MetadataItem>,
>,
>>("metadata", Self::VT_METADATA, false)?
.finish();
Ok(())
}
}
pub struct SnapshotInfoArgs<'a> {
pub id: Option<&'a ObjectId12>,
pub parent_offset: i32,
pub flushed_at: u64,
pub message: Option<::flatbuffers::WIPOffset<&'a str>>,
pub metadata: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<MetadataItem<'a>>,
>,
>,
>,
}
impl<'a> Default for SnapshotInfoArgs<'a> {
#[inline]
fn default() -> Self {
SnapshotInfoArgs {
id: None, parent_offset: 0,
flushed_at: 0,
message: None, metadata: None,
}
}
}
pub struct SnapshotInfoBuilder<'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> SnapshotInfoBuilder<'a, 'b, A> {
#[inline]
pub fn add_id(&mut self, id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(SnapshotInfo::VT_ID, id);
}
#[inline]
pub fn add_parent_offset(&mut self, parent_offset: i32) {
self.fbb_.push_slot::<i32>(SnapshotInfo::VT_PARENT_OFFSET, parent_offset, 0);
}
#[inline]
pub fn add_flushed_at(&mut self, flushed_at: u64) {
self.fbb_.push_slot::<u64>(SnapshotInfo::VT_FLUSHED_AT, flushed_at, 0);
}
#[inline]
pub fn add_message(&mut self, message: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
SnapshotInfo::VT_MESSAGE,
message,
);
}
#[inline]
pub fn add_metadata(
&mut self,
metadata: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<MetadataItem<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
SnapshotInfo::VT_METADATA,
metadata,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> SnapshotInfoBuilder<'a, 'b, A> {
let start = _fbb.start_table();
SnapshotInfoBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<SnapshotInfo<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, SnapshotInfo::VT_ID, "id");
self.fbb_.required(o, SnapshotInfo::VT_MESSAGE, "message");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for SnapshotInfo<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("SnapshotInfo");
ds.field("id", &self.id());
ds.field("parent_offset", &self.parent_offset());
ds.field("flushed_at", &self.flushed_at());
ds.field("message", &self.message());
ds.field("metadata", &self.metadata());
ds.finish()
}
}
pub enum RepoStatusOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct RepoStatus<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for RepoStatus<'a> {
type Inner = RepoStatus<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> RepoStatus<'a> {
pub const VT_AVAILABILITY: ::flatbuffers::VOffsetT = 4;
pub const VT_SET_AT: ::flatbuffers::VOffsetT = 6;
pub const VT_LIMITED_AVAILABILITY_REASON: ::flatbuffers::VOffsetT = 8;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
RepoStatus { _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 RepoStatusArgs<'args>,
) -> ::flatbuffers::WIPOffset<RepoStatus<'bldr>> {
let mut builder = RepoStatusBuilder::new(_fbb);
builder.add_set_at(args.set_at);
if let Some(x) = args.limited_availability_reason {
builder.add_limited_availability_reason(x);
}
builder.add_availability(args.availability);
builder.finish()
}
#[inline]
pub fn availability(&self) -> RepoAvailability {
unsafe {
self._tab
.get::<RepoAvailability>(
RepoStatus::VT_AVAILABILITY,
Some(RepoAvailability::Online),
)
.unwrap()
}
}
#[inline]
pub fn set_at(&self) -> u64 {
unsafe { self._tab.get::<u64>(RepoStatus::VT_SET_AT, Some(0)).unwrap() }
}
#[inline]
pub fn limited_availability_reason(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
RepoStatus::VT_LIMITED_AVAILABILITY_REASON,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for RepoStatus<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<RepoAvailability>(
"availability",
Self::VT_AVAILABILITY,
false,
)?
.visit_field::<u64>("set_at", Self::VT_SET_AT, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"limited_availability_reason",
Self::VT_LIMITED_AVAILABILITY_REASON,
false,
)?
.finish();
Ok(())
}
}
pub struct RepoStatusArgs<'a> {
pub availability: RepoAvailability,
pub set_at: u64,
pub limited_availability_reason: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for RepoStatusArgs<'a> {
#[inline]
fn default() -> Self {
RepoStatusArgs {
availability: RepoAvailability::Online,
set_at: 0,
limited_availability_reason: None,
}
}
}
pub struct RepoStatusBuilder<'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> RepoStatusBuilder<'a, 'b, A> {
#[inline]
pub fn add_availability(&mut self, availability: RepoAvailability) {
self.fbb_.push_slot::<RepoAvailability>(
RepoStatus::VT_AVAILABILITY,
availability,
RepoAvailability::Online,
);
}
#[inline]
pub fn add_set_at(&mut self, set_at: u64) {
self.fbb_.push_slot::<u64>(RepoStatus::VT_SET_AT, set_at, 0);
}
#[inline]
pub fn add_limited_availability_reason(
&mut self,
limited_availability_reason: ::flatbuffers::WIPOffset<&'b str>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
RepoStatus::VT_LIMITED_AVAILABILITY_REASON,
limited_availability_reason,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> RepoStatusBuilder<'a, 'b, A> {
let start = _fbb.start_table();
RepoStatusBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<RepoStatus<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for RepoStatus<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("RepoStatus");
ds.field("availability", &self.availability());
ds.field("set_at", &self.set_at());
ds.field("limited_availability_reason", &self.limited_availability_reason());
ds.finish()
}
}
pub enum RepoInitializedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct RepoInitializedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for RepoInitializedUpdate<'a> {
type Inner = RepoInitializedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> RepoInitializedUpdate<'a> {
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
RepoInitializedUpdate { _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 RepoInitializedUpdateArgs,
) -> ::flatbuffers::WIPOffset<RepoInitializedUpdate<'bldr>> {
let mut builder = RepoInitializedUpdateBuilder::new(_fbb);
builder.finish()
}
}
impl ::flatbuffers::Verifiable for RepoInitializedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?.finish();
Ok(())
}
}
pub struct RepoInitializedUpdateArgs {}
impl<'a> Default for RepoInitializedUpdateArgs {
#[inline]
fn default() -> Self {
RepoInitializedUpdateArgs {}
}
}
pub struct RepoInitializedUpdateBuilder<'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>
RepoInitializedUpdateBuilder<'a, 'b, A>
{
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> RepoInitializedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
RepoInitializedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<RepoInitializedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for RepoInitializedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("RepoInitializedUpdate");
ds.finish()
}
}
pub enum RepoMigratedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct RepoMigratedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for RepoMigratedUpdate<'a> {
type Inner = RepoMigratedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> RepoMigratedUpdate<'a> {
pub const VT_FROM_VERSION: ::flatbuffers::VOffsetT = 4;
pub const VT_TO_VERSION: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
RepoMigratedUpdate { _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 RepoMigratedUpdateArgs,
) -> ::flatbuffers::WIPOffset<RepoMigratedUpdate<'bldr>> {
let mut builder = RepoMigratedUpdateBuilder::new(_fbb);
builder.add_to_version(args.to_version);
builder.add_from_version(args.from_version);
builder.finish()
}
#[inline]
pub fn from_version(&self) -> u8 {
unsafe {
self._tab.get::<u8>(RepoMigratedUpdate::VT_FROM_VERSION, Some(0)).unwrap()
}
}
#[inline]
pub fn to_version(&self) -> u8 {
unsafe {
self._tab.get::<u8>(RepoMigratedUpdate::VT_TO_VERSION, Some(0)).unwrap()
}
}
}
impl ::flatbuffers::Verifiable for RepoMigratedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<u8>("from_version", Self::VT_FROM_VERSION, false)?
.visit_field::<u8>("to_version", Self::VT_TO_VERSION, false)?
.finish();
Ok(())
}
}
pub struct RepoMigratedUpdateArgs {
pub from_version: u8,
pub to_version: u8,
}
impl<'a> Default for RepoMigratedUpdateArgs {
#[inline]
fn default() -> Self {
RepoMigratedUpdateArgs { from_version: 0, to_version: 0 }
}
}
pub struct RepoMigratedUpdateBuilder<'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> RepoMigratedUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn add_from_version(&mut self, from_version: u8) {
self.fbb_.push_slot::<u8>(
RepoMigratedUpdate::VT_FROM_VERSION,
from_version,
0,
);
}
#[inline]
pub fn add_to_version(&mut self, to_version: u8) {
self.fbb_.push_slot::<u8>(RepoMigratedUpdate::VT_TO_VERSION, to_version, 0);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> RepoMigratedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
RepoMigratedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<RepoMigratedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for RepoMigratedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("RepoMigratedUpdate");
ds.field("from_version", &self.from_version());
ds.field("to_version", &self.to_version());
ds.finish()
}
}
pub enum RepoStatusChangedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct RepoStatusChangedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for RepoStatusChangedUpdate<'a> {
type Inner = RepoStatusChangedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> RepoStatusChangedUpdate<'a> {
pub const VT_STATUS: ::flatbuffers::VOffsetT = 4;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
RepoStatusChangedUpdate { _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 RepoStatusChangedUpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<RepoStatusChangedUpdate<'bldr>> {
let mut builder = RepoStatusChangedUpdateBuilder::new(_fbb);
if let Some(x) = args.status {
builder.add_status(x);
}
builder.finish()
}
#[inline]
pub fn status(&self) -> Option<RepoStatus<'a>> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<RepoStatus>>(
RepoStatusChangedUpdate::VT_STATUS,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for RepoStatusChangedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<RepoStatus>>(
"status",
Self::VT_STATUS,
false,
)?
.finish();
Ok(())
}
}
pub struct RepoStatusChangedUpdateArgs<'a> {
pub status: Option<::flatbuffers::WIPOffset<RepoStatus<'a>>>,
}
impl<'a> Default for RepoStatusChangedUpdateArgs<'a> {
#[inline]
fn default() -> Self {
RepoStatusChangedUpdateArgs { status: None }
}
}
pub struct RepoStatusChangedUpdateBuilder<
'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>
RepoStatusChangedUpdateBuilder<'a, 'b, A>
{
#[inline]
pub fn add_status(&mut self, status: ::flatbuffers::WIPOffset<RepoStatus<'b>>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<RepoStatus>>(
RepoStatusChangedUpdate::VT_STATUS,
status,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> RepoStatusChangedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
RepoStatusChangedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<RepoStatusChangedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for RepoStatusChangedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("RepoStatusChangedUpdate");
ds.field("status", &self.status());
ds.finish()
}
}
pub enum ConfigChangedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ConfigChangedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ConfigChangedUpdate<'a> {
type Inner = ConfigChangedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> ConfigChangedUpdate<'a> {
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ConfigChangedUpdate { _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 ConfigChangedUpdateArgs,
) -> ::flatbuffers::WIPOffset<ConfigChangedUpdate<'bldr>> {
let mut builder = ConfigChangedUpdateBuilder::new(_fbb);
builder.finish()
}
}
impl ::flatbuffers::Verifiable for ConfigChangedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?.finish();
Ok(())
}
}
pub struct ConfigChangedUpdateArgs {}
impl<'a> Default for ConfigChangedUpdateArgs {
#[inline]
fn default() -> Self {
ConfigChangedUpdateArgs {}
}
}
pub struct ConfigChangedUpdateBuilder<'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> ConfigChangedUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ConfigChangedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ConfigChangedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ConfigChangedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ConfigChangedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ConfigChangedUpdate");
ds.finish()
}
}
pub enum MetadataChangedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct MetadataChangedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for MetadataChangedUpdate<'a> {
type Inner = MetadataChangedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> MetadataChangedUpdate<'a> {
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
MetadataChangedUpdate { _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 MetadataChangedUpdateArgs,
) -> ::flatbuffers::WIPOffset<MetadataChangedUpdate<'bldr>> {
let mut builder = MetadataChangedUpdateBuilder::new(_fbb);
builder.finish()
}
}
impl ::flatbuffers::Verifiable for MetadataChangedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?.finish();
Ok(())
}
}
pub struct MetadataChangedUpdateArgs {}
impl<'a> Default for MetadataChangedUpdateArgs {
#[inline]
fn default() -> Self {
MetadataChangedUpdateArgs {}
}
}
pub struct MetadataChangedUpdateBuilder<'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>
MetadataChangedUpdateBuilder<'a, 'b, A>
{
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> MetadataChangedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
MetadataChangedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<MetadataChangedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for MetadataChangedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("MetadataChangedUpdate");
ds.finish()
}
}
pub enum TagCreatedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct TagCreatedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for TagCreatedUpdate<'a> {
type Inner = TagCreatedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> TagCreatedUpdate<'a> {
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
TagCreatedUpdate { _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 TagCreatedUpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<TagCreatedUpdate<'bldr>> {
let mut builder = TagCreatedUpdateBuilder::new(_fbb);
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
TagCreatedUpdate::VT_NAME,
None,
)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for TagCreatedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"name",
Self::VT_NAME,
true,
)?
.finish();
Ok(())
}
}
pub struct TagCreatedUpdateArgs<'a> {
pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for TagCreatedUpdateArgs<'a> {
#[inline]
fn default() -> Self {
TagCreatedUpdateArgs {
name: None, }
}
}
pub struct TagCreatedUpdateBuilder<'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> TagCreatedUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TagCreatedUpdate::VT_NAME,
name,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> TagCreatedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
TagCreatedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<TagCreatedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, TagCreatedUpdate::VT_NAME, "name");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for TagCreatedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("TagCreatedUpdate");
ds.field("name", &self.name());
ds.finish()
}
}
pub enum TagDeletedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct TagDeletedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for TagDeletedUpdate<'a> {
type Inner = TagDeletedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> TagDeletedUpdate<'a> {
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
pub const VT_PREVIOUS_SNAP_ID: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
TagDeletedUpdate { _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 TagDeletedUpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<TagDeletedUpdate<'bldr>> {
let mut builder = TagDeletedUpdateBuilder::new(_fbb);
if let Some(x) = args.previous_snap_id {
builder.add_previous_snap_id(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
TagDeletedUpdate::VT_NAME,
None,
)
.unwrap()
}
}
#[inline]
pub fn previous_snap_id(&self) -> &'a ObjectId12 {
unsafe {
self._tab
.get::<ObjectId12>(TagDeletedUpdate::VT_PREVIOUS_SNAP_ID, None)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for TagDeletedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"name",
Self::VT_NAME,
true,
)?
.visit_field::<ObjectId12>(
"previous_snap_id",
Self::VT_PREVIOUS_SNAP_ID,
true,
)?
.finish();
Ok(())
}
}
pub struct TagDeletedUpdateArgs<'a> {
pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
pub previous_snap_id: Option<&'a ObjectId12>,
}
impl<'a> Default for TagDeletedUpdateArgs<'a> {
#[inline]
fn default() -> Self {
TagDeletedUpdateArgs {
name: None, previous_snap_id: None, }
}
}
pub struct TagDeletedUpdateBuilder<'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> TagDeletedUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TagDeletedUpdate::VT_NAME,
name,
);
}
#[inline]
pub fn add_previous_snap_id(&mut self, previous_snap_id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(
TagDeletedUpdate::VT_PREVIOUS_SNAP_ID,
previous_snap_id,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> TagDeletedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
TagDeletedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<TagDeletedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, TagDeletedUpdate::VT_NAME, "name");
self.fbb_.required(
o,
TagDeletedUpdate::VT_PREVIOUS_SNAP_ID,
"previous_snap_id",
);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for TagDeletedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("TagDeletedUpdate");
ds.field("name", &self.name());
ds.field("previous_snap_id", &self.previous_snap_id());
ds.finish()
}
}
pub enum BranchCreatedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct BranchCreatedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for BranchCreatedUpdate<'a> {
type Inner = BranchCreatedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> BranchCreatedUpdate<'a> {
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
BranchCreatedUpdate { _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 BranchCreatedUpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<BranchCreatedUpdate<'bldr>> {
let mut builder = BranchCreatedUpdateBuilder::new(_fbb);
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
BranchCreatedUpdate::VT_NAME,
None,
)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for BranchCreatedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"name",
Self::VT_NAME,
true,
)?
.finish();
Ok(())
}
}
pub struct BranchCreatedUpdateArgs<'a> {
pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for BranchCreatedUpdateArgs<'a> {
#[inline]
fn default() -> Self {
BranchCreatedUpdateArgs {
name: None, }
}
}
pub struct BranchCreatedUpdateBuilder<'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> BranchCreatedUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
BranchCreatedUpdate::VT_NAME,
name,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> BranchCreatedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
BranchCreatedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<BranchCreatedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, BranchCreatedUpdate::VT_NAME, "name");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for BranchCreatedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("BranchCreatedUpdate");
ds.field("name", &self.name());
ds.finish()
}
}
pub enum BranchDeletedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct BranchDeletedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for BranchDeletedUpdate<'a> {
type Inner = BranchDeletedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> BranchDeletedUpdate<'a> {
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
pub const VT_PREVIOUS_SNAP_ID: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
BranchDeletedUpdate { _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 BranchDeletedUpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<BranchDeletedUpdate<'bldr>> {
let mut builder = BranchDeletedUpdateBuilder::new(_fbb);
if let Some(x) = args.previous_snap_id {
builder.add_previous_snap_id(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
BranchDeletedUpdate::VT_NAME,
None,
)
.unwrap()
}
}
#[inline]
pub fn previous_snap_id(&self) -> &'a ObjectId12 {
unsafe {
self._tab
.get::<ObjectId12>(BranchDeletedUpdate::VT_PREVIOUS_SNAP_ID, None)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for BranchDeletedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"name",
Self::VT_NAME,
true,
)?
.visit_field::<ObjectId12>(
"previous_snap_id",
Self::VT_PREVIOUS_SNAP_ID,
true,
)?
.finish();
Ok(())
}
}
pub struct BranchDeletedUpdateArgs<'a> {
pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
pub previous_snap_id: Option<&'a ObjectId12>,
}
impl<'a> Default for BranchDeletedUpdateArgs<'a> {
#[inline]
fn default() -> Self {
BranchDeletedUpdateArgs {
name: None, previous_snap_id: None, }
}
}
pub struct BranchDeletedUpdateBuilder<'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> BranchDeletedUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
BranchDeletedUpdate::VT_NAME,
name,
);
}
#[inline]
pub fn add_previous_snap_id(&mut self, previous_snap_id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(
BranchDeletedUpdate::VT_PREVIOUS_SNAP_ID,
previous_snap_id,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> BranchDeletedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
BranchDeletedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<BranchDeletedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, BranchDeletedUpdate::VT_NAME, "name");
self.fbb_.required(
o,
BranchDeletedUpdate::VT_PREVIOUS_SNAP_ID,
"previous_snap_id",
);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for BranchDeletedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("BranchDeletedUpdate");
ds.field("name", &self.name());
ds.field("previous_snap_id", &self.previous_snap_id());
ds.finish()
}
}
pub enum BranchResetUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct BranchResetUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for BranchResetUpdate<'a> {
type Inner = BranchResetUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> BranchResetUpdate<'a> {
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
pub const VT_PREVIOUS_SNAP_ID: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
BranchResetUpdate { _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 BranchResetUpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<BranchResetUpdate<'bldr>> {
let mut builder = BranchResetUpdateBuilder::new(_fbb);
if let Some(x) = args.previous_snap_id {
builder.add_previous_snap_id(x);
}
if let Some(x) = args.name {
builder.add_name(x);
}
builder.finish()
}
#[inline]
pub fn name(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
BranchResetUpdate::VT_NAME,
None,
)
.unwrap()
}
}
#[inline]
pub fn previous_snap_id(&self) -> &'a ObjectId12 {
unsafe {
self._tab
.get::<ObjectId12>(BranchResetUpdate::VT_PREVIOUS_SNAP_ID, None)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for BranchResetUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"name",
Self::VT_NAME,
true,
)?
.visit_field::<ObjectId12>(
"previous_snap_id",
Self::VT_PREVIOUS_SNAP_ID,
true,
)?
.finish();
Ok(())
}
}
pub struct BranchResetUpdateArgs<'a> {
pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
pub previous_snap_id: Option<&'a ObjectId12>,
}
impl<'a> Default for BranchResetUpdateArgs<'a> {
#[inline]
fn default() -> Self {
BranchResetUpdateArgs {
name: None, previous_snap_id: None, }
}
}
pub struct BranchResetUpdateBuilder<'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> BranchResetUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
BranchResetUpdate::VT_NAME,
name,
);
}
#[inline]
pub fn add_previous_snap_id(&mut self, previous_snap_id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(
BranchResetUpdate::VT_PREVIOUS_SNAP_ID,
previous_snap_id,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> BranchResetUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
BranchResetUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<BranchResetUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, BranchResetUpdate::VT_NAME, "name");
self.fbb_.required(
o,
BranchResetUpdate::VT_PREVIOUS_SNAP_ID,
"previous_snap_id",
);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for BranchResetUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("BranchResetUpdate");
ds.field("name", &self.name());
ds.field("previous_snap_id", &self.previous_snap_id());
ds.finish()
}
}
pub enum NewCommitUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct NewCommitUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for NewCommitUpdate<'a> {
type Inner = NewCommitUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> NewCommitUpdate<'a> {
pub const VT_BRANCH: ::flatbuffers::VOffsetT = 4;
pub const VT_NEW_SNAP_ID: ::flatbuffers::VOffsetT = 6;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
NewCommitUpdate { _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 NewCommitUpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<NewCommitUpdate<'bldr>> {
let mut builder = NewCommitUpdateBuilder::new(_fbb);
if let Some(x) = args.new_snap_id {
builder.add_new_snap_id(x);
}
if let Some(x) = args.branch {
builder.add_branch(x);
}
builder.finish()
}
#[inline]
pub fn branch(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
NewCommitUpdate::VT_BRANCH,
None,
)
.unwrap()
}
}
#[inline]
pub fn new_snap_id(&self) -> &'a ObjectId12 {
unsafe {
self._tab
.get::<ObjectId12>(NewCommitUpdate::VT_NEW_SNAP_ID, None)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for NewCommitUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"branch",
Self::VT_BRANCH,
true,
)?
.visit_field::<ObjectId12>("new_snap_id", Self::VT_NEW_SNAP_ID, true)?
.finish();
Ok(())
}
}
pub struct NewCommitUpdateArgs<'a> {
pub branch: Option<::flatbuffers::WIPOffset<&'a str>>,
pub new_snap_id: Option<&'a ObjectId12>,
}
impl<'a> Default for NewCommitUpdateArgs<'a> {
#[inline]
fn default() -> Self {
NewCommitUpdateArgs {
branch: None, new_snap_id: None, }
}
}
pub struct NewCommitUpdateBuilder<'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> NewCommitUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn add_branch(&mut self, branch: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
NewCommitUpdate::VT_BRANCH,
branch,
);
}
#[inline]
pub fn add_new_snap_id(&mut self, new_snap_id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(
NewCommitUpdate::VT_NEW_SNAP_ID,
new_snap_id,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> NewCommitUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
NewCommitUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<NewCommitUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, NewCommitUpdate::VT_BRANCH, "branch");
self.fbb_.required(o, NewCommitUpdate::VT_NEW_SNAP_ID, "new_snap_id");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for NewCommitUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("NewCommitUpdate");
ds.field("branch", &self.branch());
ds.field("new_snap_id", &self.new_snap_id());
ds.finish()
}
}
pub enum CommitAmendedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct CommitAmendedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for CommitAmendedUpdate<'a> {
type Inner = CommitAmendedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> CommitAmendedUpdate<'a> {
pub const VT_BRANCH: ::flatbuffers::VOffsetT = 4;
pub const VT_PREVIOUS_SNAP_ID: ::flatbuffers::VOffsetT = 6;
pub const VT_NEW_SNAP_ID: ::flatbuffers::VOffsetT = 8;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
CommitAmendedUpdate { _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 CommitAmendedUpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<CommitAmendedUpdate<'bldr>> {
let mut builder = CommitAmendedUpdateBuilder::new(_fbb);
if let Some(x) = args.new_snap_id {
builder.add_new_snap_id(x);
}
if let Some(x) = args.previous_snap_id {
builder.add_previous_snap_id(x);
}
if let Some(x) = args.branch {
builder.add_branch(x);
}
builder.finish()
}
#[inline]
pub fn branch(&self) -> &'a str {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(
CommitAmendedUpdate::VT_BRANCH,
None,
)
.unwrap()
}
}
#[inline]
pub fn previous_snap_id(&self) -> &'a ObjectId12 {
unsafe {
self._tab
.get::<ObjectId12>(CommitAmendedUpdate::VT_PREVIOUS_SNAP_ID, None)
.unwrap()
}
}
#[inline]
pub fn new_snap_id(&self) -> &'a ObjectId12 {
unsafe {
self._tab
.get::<ObjectId12>(CommitAmendedUpdate::VT_NEW_SNAP_ID, None)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for CommitAmendedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"branch",
Self::VT_BRANCH,
true,
)?
.visit_field::<ObjectId12>(
"previous_snap_id",
Self::VT_PREVIOUS_SNAP_ID,
true,
)?
.visit_field::<ObjectId12>("new_snap_id", Self::VT_NEW_SNAP_ID, true)?
.finish();
Ok(())
}
}
pub struct CommitAmendedUpdateArgs<'a> {
pub branch: Option<::flatbuffers::WIPOffset<&'a str>>,
pub previous_snap_id: Option<&'a ObjectId12>,
pub new_snap_id: Option<&'a ObjectId12>,
}
impl<'a> Default for CommitAmendedUpdateArgs<'a> {
#[inline]
fn default() -> Self {
CommitAmendedUpdateArgs {
branch: None, previous_snap_id: None, new_snap_id: None, }
}
}
pub struct CommitAmendedUpdateBuilder<'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> CommitAmendedUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn add_branch(&mut self, branch: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
CommitAmendedUpdate::VT_BRANCH,
branch,
);
}
#[inline]
pub fn add_previous_snap_id(&mut self, previous_snap_id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(
CommitAmendedUpdate::VT_PREVIOUS_SNAP_ID,
previous_snap_id,
);
}
#[inline]
pub fn add_new_snap_id(&mut self, new_snap_id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(
CommitAmendedUpdate::VT_NEW_SNAP_ID,
new_snap_id,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> CommitAmendedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
CommitAmendedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<CommitAmendedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, CommitAmendedUpdate::VT_BRANCH, "branch");
self.fbb_.required(
o,
CommitAmendedUpdate::VT_PREVIOUS_SNAP_ID,
"previous_snap_id",
);
self.fbb_.required(o, CommitAmendedUpdate::VT_NEW_SNAP_ID, "new_snap_id");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for CommitAmendedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("CommitAmendedUpdate");
ds.field("branch", &self.branch());
ds.field("previous_snap_id", &self.previous_snap_id());
ds.field("new_snap_id", &self.new_snap_id());
ds.finish()
}
}
pub enum NewDetachedSnapshotUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct NewDetachedSnapshotUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for NewDetachedSnapshotUpdate<'a> {
type Inner = NewDetachedSnapshotUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> NewDetachedSnapshotUpdate<'a> {
pub const VT_NEW_SNAP_ID: ::flatbuffers::VOffsetT = 4;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
NewDetachedSnapshotUpdate { _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 NewDetachedSnapshotUpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<NewDetachedSnapshotUpdate<'bldr>> {
let mut builder = NewDetachedSnapshotUpdateBuilder::new(_fbb);
if let Some(x) = args.new_snap_id {
builder.add_new_snap_id(x);
}
builder.finish()
}
#[inline]
pub fn new_snap_id(&self) -> &'a ObjectId12 {
unsafe {
self._tab
.get::<ObjectId12>(NewDetachedSnapshotUpdate::VT_NEW_SNAP_ID, None)
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for NewDetachedSnapshotUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ObjectId12>("new_snap_id", Self::VT_NEW_SNAP_ID, true)?
.finish();
Ok(())
}
}
pub struct NewDetachedSnapshotUpdateArgs<'a> {
pub new_snap_id: Option<&'a ObjectId12>,
}
impl<'a> Default for NewDetachedSnapshotUpdateArgs<'a> {
#[inline]
fn default() -> Self {
NewDetachedSnapshotUpdateArgs {
new_snap_id: None, }
}
}
pub struct NewDetachedSnapshotUpdateBuilder<
'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>
NewDetachedSnapshotUpdateBuilder<'a, 'b, A>
{
#[inline]
pub fn add_new_snap_id(&mut self, new_snap_id: &ObjectId12) {
self.fbb_.push_slot_always::<&ObjectId12>(
NewDetachedSnapshotUpdate::VT_NEW_SNAP_ID,
new_snap_id,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> NewDetachedSnapshotUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
NewDetachedSnapshotUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<NewDetachedSnapshotUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(
o,
NewDetachedSnapshotUpdate::VT_NEW_SNAP_ID,
"new_snap_id",
);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for NewDetachedSnapshotUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("NewDetachedSnapshotUpdate");
ds.field("new_snap_id", &self.new_snap_id());
ds.finish()
}
}
pub enum GCRanUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct GCRanUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for GCRanUpdate<'a> {
type Inner = GCRanUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> GCRanUpdate<'a> {
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
GCRanUpdate { _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 GCRanUpdateArgs,
) -> ::flatbuffers::WIPOffset<GCRanUpdate<'bldr>> {
let mut builder = GCRanUpdateBuilder::new(_fbb);
builder.finish()
}
}
impl ::flatbuffers::Verifiable for GCRanUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?.finish();
Ok(())
}
}
pub struct GCRanUpdateArgs {}
impl<'a> Default for GCRanUpdateArgs {
#[inline]
fn default() -> Self {
GCRanUpdateArgs {}
}
}
pub struct GCRanUpdateBuilder<'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> GCRanUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> GCRanUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
GCRanUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<GCRanUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for GCRanUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("GCRanUpdate");
ds.finish()
}
}
pub enum ExpirationRanUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ExpirationRanUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ExpirationRanUpdate<'a> {
type Inner = ExpirationRanUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> ExpirationRanUpdate<'a> {
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ExpirationRanUpdate { _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 ExpirationRanUpdateArgs,
) -> ::flatbuffers::WIPOffset<ExpirationRanUpdate<'bldr>> {
let mut builder = ExpirationRanUpdateBuilder::new(_fbb);
builder.finish()
}
}
impl ::flatbuffers::Verifiable for ExpirationRanUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?.finish();
Ok(())
}
}
pub struct ExpirationRanUpdateArgs {}
impl<'a> Default for ExpirationRanUpdateArgs {
#[inline]
fn default() -> Self {
ExpirationRanUpdateArgs {}
}
}
pub struct ExpirationRanUpdateBuilder<'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> ExpirationRanUpdateBuilder<'a, 'b, A> {
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ExpirationRanUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ExpirationRanUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ExpirationRanUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ExpirationRanUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ExpirationRanUpdate");
ds.finish()
}
}
pub enum FeatureFlagChangedUpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct FeatureFlagChangedUpdate<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for FeatureFlagChangedUpdate<'a> {
type Inner = FeatureFlagChangedUpdate<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> FeatureFlagChangedUpdate<'a> {
pub const VT_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_NEW_VALUE: ::flatbuffers::VOffsetT = 6;
pub const VT_IS_SET: ::flatbuffers::VOffsetT = 8;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
FeatureFlagChangedUpdate { _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 FeatureFlagChangedUpdateArgs,
) -> ::flatbuffers::WIPOffset<FeatureFlagChangedUpdate<'bldr>> {
let mut builder = FeatureFlagChangedUpdateBuilder::new(_fbb);
builder.add_id(args.id);
builder.add_is_set(args.is_set);
builder.add_new_value(args.new_value);
builder.finish()
}
#[inline]
pub fn id(&self) -> u16 {
unsafe {
self._tab.get::<u16>(FeatureFlagChangedUpdate::VT_ID, Some(0)).unwrap()
}
}
#[inline]
pub fn new_value(&self) -> bool {
unsafe {
self._tab
.get::<bool>(FeatureFlagChangedUpdate::VT_NEW_VALUE, Some(false))
.unwrap()
}
}
#[inline]
pub fn is_set(&self) -> bool {
unsafe {
self._tab
.get::<bool>(FeatureFlagChangedUpdate::VT_IS_SET, Some(false))
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for FeatureFlagChangedUpdate<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<u16>("id", Self::VT_ID, false)?
.visit_field::<bool>("new_value", Self::VT_NEW_VALUE, false)?
.visit_field::<bool>("is_set", Self::VT_IS_SET, false)?
.finish();
Ok(())
}
}
pub struct FeatureFlagChangedUpdateArgs {
pub id: u16,
pub new_value: bool,
pub is_set: bool,
}
impl<'a> Default for FeatureFlagChangedUpdateArgs {
#[inline]
fn default() -> Self {
FeatureFlagChangedUpdateArgs { id: 0, new_value: false, is_set: false }
}
}
pub struct FeatureFlagChangedUpdateBuilder<
'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>
FeatureFlagChangedUpdateBuilder<'a, 'b, A>
{
#[inline]
pub fn add_id(&mut self, id: u16) {
self.fbb_.push_slot::<u16>(FeatureFlagChangedUpdate::VT_ID, id, 0);
}
#[inline]
pub fn add_new_value(&mut self, new_value: bool) {
self.fbb_.push_slot::<bool>(
FeatureFlagChangedUpdate::VT_NEW_VALUE,
new_value,
false,
);
}
#[inline]
pub fn add_is_set(&mut self, is_set: bool) {
self.fbb_.push_slot::<bool>(
FeatureFlagChangedUpdate::VT_IS_SET,
is_set,
false,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> FeatureFlagChangedUpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
FeatureFlagChangedUpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<FeatureFlagChangedUpdate<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for FeatureFlagChangedUpdate<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("FeatureFlagChangedUpdate");
ds.field("id", &self.id());
ds.field("new_value", &self.new_value());
ds.field("is_set", &self.is_set());
ds.finish()
}
}
pub enum UpdateOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Update<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for Update<'a> {
type Inner = Update<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> Update<'a> {
pub const VT_UPDATE_TYPE_TYPE: ::flatbuffers::VOffsetT = 4;
pub const VT_UPDATE_TYPE: ::flatbuffers::VOffsetT = 6;
pub const VT_UPDATED_AT: ::flatbuffers::VOffsetT = 8;
pub const VT_BACKUP_PATH: ::flatbuffers::VOffsetT = 10;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
Update { _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 UpdateArgs<'args>,
) -> ::flatbuffers::WIPOffset<Update<'bldr>> {
let mut builder = UpdateBuilder::new(_fbb);
builder.add_updated_at(args.updated_at);
if let Some(x) = args.backup_path {
builder.add_backup_path(x);
}
if let Some(x) = args.update_type {
builder.add_update_type(x);
}
builder.add_update_type_type(args.update_type_type);
builder.finish()
}
#[inline]
pub fn update_type_type(&self) -> UpdateType {
unsafe {
self._tab
.get::<UpdateType>(
Update::VT_UPDATE_TYPE_TYPE,
Some(UpdateType::NONE),
)
.unwrap()
}
}
#[inline]
pub fn update_type(&self) -> ::flatbuffers::Table<'a> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
Update::VT_UPDATE_TYPE,
None,
)
.unwrap()
}
}
#[inline]
pub fn updated_at(&self) -> u64 {
unsafe { self._tab.get::<u64>(Update::VT_UPDATED_AT, Some(0)).unwrap() }
}
#[inline]
pub fn backup_path(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
Update::VT_BACKUP_PATH,
None,
)
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_repo_initialized_update(
&self,
) -> Option<RepoInitializedUpdate<'a>> {
if self.update_type_type() == UpdateType::RepoInitializedUpdate {
let u = self.update_type();
Some(unsafe { RepoInitializedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_repo_migrated_update(
&self,
) -> Option<RepoMigratedUpdate<'a>> {
if self.update_type_type() == UpdateType::RepoMigratedUpdate {
let u = self.update_type();
Some(unsafe { RepoMigratedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_config_changed_update(
&self,
) -> Option<ConfigChangedUpdate<'a>> {
if self.update_type_type() == UpdateType::ConfigChangedUpdate {
let u = self.update_type();
Some(unsafe { ConfigChangedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_metadata_changed_update(
&self,
) -> Option<MetadataChangedUpdate<'a>> {
if self.update_type_type() == UpdateType::MetadataChangedUpdate {
let u = self.update_type();
Some(unsafe { MetadataChangedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_tag_created_update(&self) -> Option<TagCreatedUpdate<'a>> {
if self.update_type_type() == UpdateType::TagCreatedUpdate {
let u = self.update_type();
Some(unsafe { TagCreatedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_tag_deleted_update(&self) -> Option<TagDeletedUpdate<'a>> {
if self.update_type_type() == UpdateType::TagDeletedUpdate {
let u = self.update_type();
Some(unsafe { TagDeletedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_branch_created_update(
&self,
) -> Option<BranchCreatedUpdate<'a>> {
if self.update_type_type() == UpdateType::BranchCreatedUpdate {
let u = self.update_type();
Some(unsafe { BranchCreatedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_branch_deleted_update(
&self,
) -> Option<BranchDeletedUpdate<'a>> {
if self.update_type_type() == UpdateType::BranchDeletedUpdate {
let u = self.update_type();
Some(unsafe { BranchDeletedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_branch_reset_update(
&self,
) -> Option<BranchResetUpdate<'a>> {
if self.update_type_type() == UpdateType::BranchResetUpdate {
let u = self.update_type();
Some(unsafe { BranchResetUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_new_commit_update(&self) -> Option<NewCommitUpdate<'a>> {
if self.update_type_type() == UpdateType::NewCommitUpdate {
let u = self.update_type();
Some(unsafe { NewCommitUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_commit_amended_update(
&self,
) -> Option<CommitAmendedUpdate<'a>> {
if self.update_type_type() == UpdateType::CommitAmendedUpdate {
let u = self.update_type();
Some(unsafe { CommitAmendedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_new_detached_snapshot_update(
&self,
) -> Option<NewDetachedSnapshotUpdate<'a>> {
if self.update_type_type() == UpdateType::NewDetachedSnapshotUpdate {
let u = self.update_type();
Some(unsafe { NewDetachedSnapshotUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_gcran_update(&self) -> Option<GCRanUpdate<'a>> {
if self.update_type_type() == UpdateType::GCRanUpdate {
let u = self.update_type();
Some(unsafe { GCRanUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_expiration_ran_update(
&self,
) -> Option<ExpirationRanUpdate<'a>> {
if self.update_type_type() == UpdateType::ExpirationRanUpdate {
let u = self.update_type();
Some(unsafe { ExpirationRanUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_feature_flag_changed_update(
&self,
) -> Option<FeatureFlagChangedUpdate<'a>> {
if self.update_type_type() == UpdateType::FeatureFlagChangedUpdate {
let u = self.update_type();
Some(unsafe { FeatureFlagChangedUpdate::init_from_table(u) })
} else {
None
}
}
#[inline]
#[allow(non_snake_case)]
pub fn update_type_as_repo_status_changed_update(
&self,
) -> Option<RepoStatusChangedUpdate<'a>> {
if self.update_type_type() == UpdateType::RepoStatusChangedUpdate {
let u = self.update_type();
Some(unsafe { RepoStatusChangedUpdate::init_from_table(u) })
} else {
None
}
}
}
impl ::flatbuffers::Verifiable for Update<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_union::<UpdateType, _>("update_type_type", Self::VT_UPDATE_TYPE_TYPE, "update_type", Self::VT_UPDATE_TYPE, true, |key, v, pos| {
match key {
UpdateType::RepoInitializedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RepoInitializedUpdate>>("UpdateType::RepoInitializedUpdate", pos),
UpdateType::RepoMigratedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RepoMigratedUpdate>>("UpdateType::RepoMigratedUpdate", pos),
UpdateType::ConfigChangedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ConfigChangedUpdate>>("UpdateType::ConfigChangedUpdate", pos),
UpdateType::MetadataChangedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<MetadataChangedUpdate>>("UpdateType::MetadataChangedUpdate", pos),
UpdateType::TagCreatedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<TagCreatedUpdate>>("UpdateType::TagCreatedUpdate", pos),
UpdateType::TagDeletedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<TagDeletedUpdate>>("UpdateType::TagDeletedUpdate", pos),
UpdateType::BranchCreatedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<BranchCreatedUpdate>>("UpdateType::BranchCreatedUpdate", pos),
UpdateType::BranchDeletedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<BranchDeletedUpdate>>("UpdateType::BranchDeletedUpdate", pos),
UpdateType::BranchResetUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<BranchResetUpdate>>("UpdateType::BranchResetUpdate", pos),
UpdateType::NewCommitUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<NewCommitUpdate>>("UpdateType::NewCommitUpdate", pos),
UpdateType::CommitAmendedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CommitAmendedUpdate>>("UpdateType::CommitAmendedUpdate", pos),
UpdateType::NewDetachedSnapshotUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<NewDetachedSnapshotUpdate>>("UpdateType::NewDetachedSnapshotUpdate", pos),
UpdateType::GCRanUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GCRanUpdate>>("UpdateType::GCRanUpdate", pos),
UpdateType::ExpirationRanUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ExpirationRanUpdate>>("UpdateType::ExpirationRanUpdate", pos),
UpdateType::FeatureFlagChangedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<FeatureFlagChangedUpdate>>("UpdateType::FeatureFlagChangedUpdate", pos),
UpdateType::RepoStatusChangedUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RepoStatusChangedUpdate>>("UpdateType::RepoStatusChangedUpdate", pos),
_ => Ok(()),
}
})?
.visit_field::<u64>("updated_at", Self::VT_UPDATED_AT, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("backup_path", Self::VT_BACKUP_PATH, false)?
.finish();
Ok(())
}
}
pub struct UpdateArgs<'a> {
pub update_type_type: UpdateType,
pub update_type: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
pub updated_at: u64,
pub backup_path: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for UpdateArgs<'a> {
#[inline]
fn default() -> Self {
UpdateArgs {
update_type_type: UpdateType::NONE,
update_type: None, updated_at: 0,
backup_path: None,
}
}
}
pub struct UpdateBuilder<'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> UpdateBuilder<'a, 'b, A> {
#[inline]
pub fn add_update_type_type(&mut self, update_type_type: UpdateType) {
self.fbb_.push_slot::<UpdateType>(
Update::VT_UPDATE_TYPE_TYPE,
update_type_type,
UpdateType::NONE,
);
}
#[inline]
pub fn add_update_type(
&mut self,
update_type: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Update::VT_UPDATE_TYPE,
update_type,
);
}
#[inline]
pub fn add_updated_at(&mut self, updated_at: u64) {
self.fbb_.push_slot::<u64>(Update::VT_UPDATED_AT, updated_at, 0);
}
#[inline]
pub fn add_backup_path(
&mut self,
backup_path: ::flatbuffers::WIPOffset<&'b str>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Update::VT_BACKUP_PATH,
backup_path,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> UpdateBuilder<'a, 'b, A> {
let start = _fbb.start_table();
UpdateBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<Update<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, Update::VT_UPDATE_TYPE, "update_type");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for Update<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("Update");
ds.field("update_type_type", &self.update_type_type());
match self.update_type_type() {
UpdateType::RepoInitializedUpdate => {
if let Some(x) = self.update_type_as_repo_initialized_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::RepoMigratedUpdate => {
if let Some(x) = self.update_type_as_repo_migrated_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::ConfigChangedUpdate => {
if let Some(x) = self.update_type_as_config_changed_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::MetadataChangedUpdate => {
if let Some(x) = self.update_type_as_metadata_changed_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::TagCreatedUpdate => {
if let Some(x) = self.update_type_as_tag_created_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::TagDeletedUpdate => {
if let Some(x) = self.update_type_as_tag_deleted_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::BranchCreatedUpdate => {
if let Some(x) = self.update_type_as_branch_created_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::BranchDeletedUpdate => {
if let Some(x) = self.update_type_as_branch_deleted_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::BranchResetUpdate => {
if let Some(x) = self.update_type_as_branch_reset_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::NewCommitUpdate => {
if let Some(x) = self.update_type_as_new_commit_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::CommitAmendedUpdate => {
if let Some(x) = self.update_type_as_commit_amended_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::NewDetachedSnapshotUpdate => {
if let Some(x) = self.update_type_as_new_detached_snapshot_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::GCRanUpdate => {
if let Some(x) = self.update_type_as_gcran_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::ExpirationRanUpdate => {
if let Some(x) = self.update_type_as_expiration_ran_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::FeatureFlagChangedUpdate => {
if let Some(x) = self.update_type_as_feature_flag_changed_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
UpdateType::RepoStatusChangedUpdate => {
if let Some(x) = self.update_type_as_repo_status_changed_update() {
ds.field("update_type", &x)
} else {
ds.field("update_type", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
}
_ => {
let x: Option<()> = None;
ds.field("update_type", &x)
}
};
ds.field("updated_at", &self.updated_at());
ds.field("backup_path", &self.backup_path());
ds.finish()
}
}
pub enum RepoOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Repo<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for Repo<'a> {
type Inner = Repo<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
}
}
impl<'a> Repo<'a> {
pub const VT_SPEC_VERSION: ::flatbuffers::VOffsetT = 4;
pub const VT_TAGS: ::flatbuffers::VOffsetT = 6;
pub const VT_BRANCHES: ::flatbuffers::VOffsetT = 8;
pub const VT_DELETED_TAGS: ::flatbuffers::VOffsetT = 10;
pub const VT_SNAPSHOTS: ::flatbuffers::VOffsetT = 12;
pub const VT_STATUS: ::flatbuffers::VOffsetT = 14;
pub const VT_METADATA: ::flatbuffers::VOffsetT = 16;
pub const VT_LATEST_UPDATES: ::flatbuffers::VOffsetT = 18;
pub const VT_REPO_BEFORE_UPDATES: ::flatbuffers::VOffsetT = 20;
pub const VT_CONFIG: ::flatbuffers::VOffsetT = 22;
pub const VT_ENABLED_FEATURE_FLAGS: ::flatbuffers::VOffsetT = 24;
pub const VT_DISABLED_FEATURE_FLAGS: ::flatbuffers::VOffsetT = 26;
pub const VT_EXTRA: ::flatbuffers::VOffsetT = 28;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
Repo { _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 RepoArgs<'args>,
) -> ::flatbuffers::WIPOffset<Repo<'bldr>> {
let mut builder = RepoBuilder::new(_fbb);
if let Some(x) = args.extra {
builder.add_extra(x);
}
if let Some(x) = args.disabled_feature_flags {
builder.add_disabled_feature_flags(x);
}
if let Some(x) = args.enabled_feature_flags {
builder.add_enabled_feature_flags(x);
}
if let Some(x) = args.config {
builder.add_config(x);
}
if let Some(x) = args.repo_before_updates {
builder.add_repo_before_updates(x);
}
if let Some(x) = args.latest_updates {
builder.add_latest_updates(x);
}
if let Some(x) = args.metadata {
builder.add_metadata(x);
}
if let Some(x) = args.status {
builder.add_status(x);
}
if let Some(x) = args.snapshots {
builder.add_snapshots(x);
}
if let Some(x) = args.deleted_tags {
builder.add_deleted_tags(x);
}
if let Some(x) = args.branches {
builder.add_branches(x);
}
if let Some(x) = args.tags {
builder.add_tags(x);
}
builder.add_spec_version(args.spec_version);
builder.finish()
}
#[inline]
pub fn spec_version(&self) -> u8 {
unsafe { self._tab.get::<u8>(Repo::VT_SPEC_VERSION, Some(0)).unwrap() }
}
#[inline]
pub fn tags(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Ref<'a>>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Ref>>,
>>(Repo::VT_TAGS, None)
.unwrap()
}
}
#[inline]
pub fn branches(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Ref<'a>>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Ref>>,
>>(Repo::VT_BRANCHES, None)
.unwrap()
}
}
#[inline]
pub fn deleted_tags(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<&'a str>,
>,
>>(Repo::VT_DELETED_TAGS, None)
.unwrap()
}
}
#[inline]
pub fn snapshots(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<SnapshotInfo<'a>>>
{
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<SnapshotInfo>,
>,
>>(Repo::VT_SNAPSHOTS, None)
.unwrap()
}
}
#[inline]
pub fn status(&self) -> RepoStatus<'a> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<RepoStatus>>(
Repo::VT_STATUS,
None,
)
.unwrap()
}
}
#[inline]
pub fn metadata(
&self,
) -> Option<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MetadataItem<'a>>>,
> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<MetadataItem>,
>,
>>(Repo::VT_METADATA, None)
}
}
#[inline]
pub fn latest_updates(
&self,
) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Update<'a>>>
{
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Update>>,
>>(Repo::VT_LATEST_UPDATES, None)
.unwrap()
}
}
#[inline]
pub fn repo_before_updates(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
Repo::VT_REPO_BEFORE_UPDATES,
None,
)
}
}
#[inline]
pub fn config(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
Repo::VT_CONFIG,
None,
)
}
}
#[inline]
pub fn enabled_feature_flags(&self) -> Option<::flatbuffers::Vector<'a, u16>> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u16>>>(Repo::VT_ENABLED_FEATURE_FLAGS, None)
}
}
#[inline]
pub fn disabled_feature_flags(&self) -> Option<::flatbuffers::Vector<'a, u16>> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u16>>>(Repo::VT_DISABLED_FEATURE_FLAGS, None)
}
}
#[inline]
pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
Repo::VT_EXTRA,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for Repo<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<u8>("spec_version", Self::VT_SPEC_VERSION, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Ref>>>>("tags", Self::VT_TAGS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Ref>>>>("branches", Self::VT_BRANCHES, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("deleted_tags", Self::VT_DELETED_TAGS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<SnapshotInfo>>>>("snapshots", Self::VT_SNAPSHOTS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<RepoStatus>>("status", Self::VT_STATUS, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<MetadataItem>>>>("metadata", Self::VT_METADATA, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Update>>>>("latest_updates", Self::VT_LATEST_UPDATES, true)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("repo_before_updates", Self::VT_REPO_BEFORE_UPDATES, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("config", Self::VT_CONFIG, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u16>>>("enabled_feature_flags", Self::VT_ENABLED_FEATURE_FLAGS, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u16>>>("disabled_feature_flags", Self::VT_DISABLED_FEATURE_FLAGS, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("extra", Self::VT_EXTRA, false)?
.finish();
Ok(())
}
}
pub struct RepoArgs<'a> {
pub spec_version: u8,
pub tags: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Ref<'a>>>,
>,
>,
pub branches: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Ref<'a>>>,
>,
>,
pub deleted_tags: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
>,
>,
pub snapshots: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<SnapshotInfo<'a>>,
>,
>,
>,
pub status: Option<::flatbuffers::WIPOffset<RepoStatus<'a>>>,
pub metadata: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<MetadataItem<'a>>,
>,
>,
>,
pub latest_updates: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Update<'a>>>,
>,
>,
pub repo_before_updates: Option<::flatbuffers::WIPOffset<&'a str>>,
pub config: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
pub enabled_feature_flags:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u16>>>,
pub disabled_feature_flags:
Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u16>>>,
pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for RepoArgs<'a> {
#[inline]
fn default() -> Self {
RepoArgs {
spec_version: 0,
tags: None, branches: None, deleted_tags: None, snapshots: None, status: None, metadata: None,
latest_updates: None, repo_before_updates: None,
config: None,
enabled_feature_flags: None,
disabled_feature_flags: None,
extra: None,
}
}
}
pub struct RepoBuilder<'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> RepoBuilder<'a, 'b, A> {
#[inline]
pub fn add_spec_version(&mut self, spec_version: u8) {
self.fbb_.push_slot::<u8>(Repo::VT_SPEC_VERSION, spec_version, 0);
}
#[inline]
pub fn add_tags(
&mut self,
tags: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<Ref<'b>>>,
>,
) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<_>>(Repo::VT_TAGS, tags);
}
#[inline]
pub fn add_branches(
&mut self,
branches: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<Ref<'b>>>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Repo::VT_BRANCHES,
branches,
);
}
#[inline]
pub fn add_deleted_tags(
&mut self,
deleted_tags: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Repo::VT_DELETED_TAGS,
deleted_tags,
);
}
#[inline]
pub fn add_snapshots(
&mut self,
snapshots: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<SnapshotInfo<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Repo::VT_SNAPSHOTS,
snapshots,
);
}
#[inline]
pub fn add_status(&mut self, status: ::flatbuffers::WIPOffset<RepoStatus<'b>>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<RepoStatus>>(
Repo::VT_STATUS,
status,
);
}
#[inline]
pub fn add_metadata(
&mut self,
metadata: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<MetadataItem<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Repo::VT_METADATA,
metadata,
);
}
#[inline]
pub fn add_latest_updates(
&mut self,
latest_updates: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<Update<'b>>>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Repo::VT_LATEST_UPDATES,
latest_updates,
);
}
#[inline]
pub fn add_repo_before_updates(
&mut self,
repo_before_updates: ::flatbuffers::WIPOffset<&'b str>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Repo::VT_REPO_BEFORE_UPDATES,
repo_before_updates,
);
}
#[inline]
pub fn add_config(
&mut self,
config: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<_>>(Repo::VT_CONFIG, config);
}
#[inline]
pub fn add_enabled_feature_flags(
&mut self,
enabled_feature_flags: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, u16>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Repo::VT_ENABLED_FEATURE_FLAGS,
enabled_feature_flags,
);
}
#[inline]
pub fn add_disabled_feature_flags(
&mut self,
disabled_feature_flags: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, u16>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
Repo::VT_DISABLED_FEATURE_FLAGS,
disabled_feature_flags,
);
}
#[inline]
pub fn add_extra(
&mut self,
extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<_>>(Repo::VT_EXTRA, extra);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> RepoBuilder<'a, 'b, A> {
let start = _fbb.start_table();
RepoBuilder { fbb_: _fbb, start_: start }
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<Repo<'a>> {
let o = self.fbb_.end_table(self.start_);
self.fbb_.required(o, Repo::VT_TAGS, "tags");
self.fbb_.required(o, Repo::VT_BRANCHES, "branches");
self.fbb_.required(o, Repo::VT_DELETED_TAGS, "deleted_tags");
self.fbb_.required(o, Repo::VT_SNAPSHOTS, "snapshots");
self.fbb_.required(o, Repo::VT_STATUS, "status");
self.fbb_.required(o, Repo::VT_LATEST_UPDATES, "latest_updates");
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for Repo<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("Repo");
ds.field("spec_version", &self.spec_version());
ds.field("tags", &self.tags());
ds.field("branches", &self.branches());
ds.field("deleted_tags", &self.deleted_tags());
ds.field("snapshots", &self.snapshots());
ds.field("status", &self.status());
ds.field("metadata", &self.metadata());
ds.field("latest_updates", &self.latest_updates());
ds.field("repo_before_updates", &self.repo_before_updates());
ds.field("config", &self.config());
ds.field("enabled_feature_flags", &self.enabled_feature_flags());
ds.field("disabled_feature_flags", &self.disabled_feature_flags());
ds.field("extra", &self.extra());
ds.finish()
}
}
}