diff --git a/rust/Cargo.toml b/rust/Cargo.toml index d840437..da840f8 100644 --- a/rust/Cargo.toml +++ b/rust/Cargo.toml @@ -14,7 +14,7 @@ bincode = "1" byteorder = "1" blake3 = { version = "1", features = ["std", "traits-preview"] } bs58 = "0.5" -chrono = { version = "0.4", default-features = false } +chrono = { version = "0.4", default-features = false, features = ["serde"] } flatbuffers = "24.3" futures = { version = "0.3", default-features = false } semver = { version = "1", default-features = false } diff --git a/rust/src/client_api/client_events.rs b/rust/src/client_api/client_events.rs index 0ea0508..9b50472 100644 --- a/rust/src/client_api/client_events.rs +++ b/rust/src/client_api/client_events.rs @@ -1452,6 +1452,23 @@ impl HostResponse { "GetContractRequest reached client serialization - this is a bug" ); } + OutboundDelegateMsg::PutContractRequest(_) => { + // PutContractRequest should be handled by the executor and never + // reach client serialization. If we get here, it's a bug. + tracing::error!( + "PutContractRequest reached client serialization - this is a bug" + ); + } + OutboundDelegateMsg::UpdateContractRequest(_) => { + tracing::error!( + "UpdateContractRequest reached client serialization - this is a bug" + ); + } + OutboundDelegateMsg::SubscribeContractRequest(_) => { + tracing::error!( + "SubscribeContractRequest reached client serialization - this is a bug" + ); + } }); let messages_offset = builder.create_vector(&messages); let delegate_response_offset = FbsDelegateResponse::create( diff --git a/rust/src/delegate_interface.rs b/rust/src/delegate_interface.rs index 504ff32..60aa2a5 100644 --- a/rust/src/delegate_interface.rs +++ b/rust/src/delegate_interface.rs @@ -19,7 +19,9 @@ use crate::generated::client_request::{ use crate::common_generated::common::SecretsId as FbsSecretsId; use crate::client_api::{TryFromFbs, WsApiError}; +use crate::contract_interface::{RelatedContracts, UpdateData}; use crate::prelude::{ContractInstanceId, WrappedState, CONTRACT_KEY_SIZE}; +use crate::versioning::ContractContainer; use crate::{code_hash::CodeHash, prelude::Parameters}; const DELEGATE_HASH_LENGTH: usize = 32; @@ -458,6 +460,9 @@ pub enum InboundDelegateMsg<'a> { ApplicationMessage(ApplicationMessage), UserResponse(#[serde(borrow)] UserInputResponse<'a>), GetContractResponse(GetContractResponse), + PutContractResponse(PutContractResponse), + UpdateContractResponse(UpdateContractResponse), + SubscribeContractResponse(SubscribeContractResponse), } impl InboundDelegateMsg<'_> { @@ -468,6 +473,15 @@ impl InboundDelegateMsg<'_> { InboundDelegateMsg::GetContractResponse(r) => { InboundDelegateMsg::GetContractResponse(r) } + InboundDelegateMsg::PutContractResponse(r) => { + InboundDelegateMsg::PutContractResponse(r) + } + InboundDelegateMsg::UpdateContractResponse(r) => { + InboundDelegateMsg::UpdateContractResponse(r) + } + InboundDelegateMsg::SubscribeContractResponse(r) => { + InboundDelegateMsg::SubscribeContractResponse(r) + } } } @@ -479,6 +493,16 @@ impl InboundDelegateMsg<'_> { InboundDelegateMsg::GetContractResponse(GetContractResponse { context, .. }) => { Some(context) } + InboundDelegateMsg::PutContractResponse(PutContractResponse { context, .. }) => { + Some(context) + } + InboundDelegateMsg::UpdateContractResponse(UpdateContractResponse { + context, .. + }) => Some(context), + InboundDelegateMsg::SubscribeContractResponse(SubscribeContractResponse { + context, + .. + }) => Some(context), _ => None, } } @@ -491,6 +515,16 @@ impl InboundDelegateMsg<'_> { InboundDelegateMsg::GetContractResponse(GetContractResponse { context, .. }) => { Some(context) } + InboundDelegateMsg::PutContractResponse(PutContractResponse { context, .. }) => { + Some(context) + } + InboundDelegateMsg::UpdateContractResponse(UpdateContractResponse { + context, .. + }) => Some(context), + InboundDelegateMsg::SubscribeContractResponse(SubscribeContractResponse { + context, + .. + }) => Some(context), _ => None, } } @@ -593,6 +627,9 @@ pub enum OutboundDelegateMsg { // todo: remove when context can be accessed from the delegate environment and we pass it as reference ContextUpdated(DelegateContext), GetContractRequest(GetContractRequest), + PutContractRequest(PutContractRequest), + UpdateContractRequest(UpdateContractRequest), + SubscribeContractRequest(SubscribeContractRequest), } impl From for OutboundDelegateMsg { @@ -607,6 +644,24 @@ impl From for OutboundDelegateMsg { } } +impl From for OutboundDelegateMsg { + fn from(req: PutContractRequest) -> Self { + Self::PutContractRequest(req) + } +} + +impl From for OutboundDelegateMsg { + fn from(req: UpdateContractRequest) -> Self { + Self::UpdateContractRequest(req) + } +} + +impl From for OutboundDelegateMsg { + fn from(req: SubscribeContractRequest) -> Self { + Self::SubscribeContractRequest(req) + } +} + impl OutboundDelegateMsg { fn deser_user_input_req<'de, D>(deser: D) -> Result, D::Error> where @@ -620,6 +675,9 @@ impl OutboundDelegateMsg { match self { OutboundDelegateMsg::ApplicationMessage(msg) => msg.processed, OutboundDelegateMsg::GetContractRequest(msg) => msg.processed, + OutboundDelegateMsg::PutContractRequest(msg) => msg.processed, + OutboundDelegateMsg::UpdateContractRequest(msg) => msg.processed, + OutboundDelegateMsg::SubscribeContractRequest(msg) => msg.processed, OutboundDelegateMsg::RequestUserInput(_) => true, OutboundDelegateMsg::ContextUpdated(_) => true, } @@ -633,6 +691,16 @@ impl OutboundDelegateMsg { OutboundDelegateMsg::GetContractRequest(GetContractRequest { context, .. }) => { Some(context) } + OutboundDelegateMsg::PutContractRequest(PutContractRequest { context, .. }) => { + Some(context) + } + OutboundDelegateMsg::UpdateContractRequest(UpdateContractRequest { + context, .. + }) => Some(context), + OutboundDelegateMsg::SubscribeContractRequest(SubscribeContractRequest { + context, + .. + }) => Some(context), _ => None, } } @@ -645,6 +713,16 @@ impl OutboundDelegateMsg { OutboundDelegateMsg::GetContractRequest(GetContractRequest { context, .. }) => { Some(context) } + OutboundDelegateMsg::PutContractRequest(PutContractRequest { context, .. }) => { + Some(context) + } + OutboundDelegateMsg::UpdateContractRequest(UpdateContractRequest { + context, .. + }) => Some(context), + OutboundDelegateMsg::SubscribeContractRequest(SubscribeContractRequest { + context, + .. + }) => Some(context), _ => None, } } @@ -677,6 +755,129 @@ pub struct GetContractResponse { pub context: DelegateContext, } +/// Request to store a new contract from within a delegate. +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct PutContractRequest { + /// The contract code and parameters. + pub contract: ContractContainer, + /// The initial state for the contract. + pub state: WrappedState, + /// Related contracts that this contract depends on. + #[serde(deserialize_with = "RelatedContracts::deser_related_contracts")] + pub related_contracts: RelatedContracts<'static>, + /// Context for the delegate. + pub context: DelegateContext, + /// Whether this request has been processed. + pub processed: bool, +} + +impl PutContractRequest { + pub fn new( + contract: ContractContainer, + state: WrappedState, + related_contracts: RelatedContracts<'static>, + ) -> Self { + Self { + contract, + state, + related_contracts, + context: Default::default(), + processed: false, + } + } +} + +/// Response after attempting to store a contract from a delegate. +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct PutContractResponse { + /// The ID of the contract that was (attempted to be) stored. + pub contract_id: ContractInstanceId, + /// Success (Ok) or error message (Err). + pub result: Result<(), String>, + /// Context for the delegate. + pub context: DelegateContext, +} + +/// Request to update an existing contract's state from within a delegate. +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct UpdateContractRequest { + /// The contract to update. + pub contract_id: ContractInstanceId, + /// The update to apply (full state or delta). + #[serde(deserialize_with = "UpdateContractRequest::deser_update_data")] + pub update: UpdateData<'static>, + /// Context for the delegate. + pub context: DelegateContext, + /// Whether this request has been processed. + pub processed: bool, +} + +impl UpdateContractRequest { + pub fn new(contract_id: ContractInstanceId, update: UpdateData<'static>) -> Self { + Self { + contract_id, + update, + context: Default::default(), + processed: false, + } + } + + fn deser_update_data<'de, D>(deser: D) -> Result, D::Error> + where + D: Deserializer<'de>, + { + let value = as Deserialize>::deserialize(deser)?; + Ok(value.into_owned()) + } +} + +/// Response after attempting to update a contract from a delegate. +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct UpdateContractResponse { + /// The contract that was updated. + pub contract_id: ContractInstanceId, + /// Success (Ok) or error message (Err). + pub result: Result<(), String>, + /// Context for the delegate. + pub context: DelegateContext, +} + +/// Request to subscribe to a contract's state changes from within a delegate. +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct SubscribeContractRequest { + /// The contract to subscribe to. + pub contract_id: ContractInstanceId, + /// Context for the delegate. + pub context: DelegateContext, + /// Whether this request has been processed. + pub processed: bool, +} + +impl SubscribeContractRequest { + pub fn new(contract_id: ContractInstanceId) -> Self { + Self { + contract_id, + context: Default::default(), + processed: false, + } + } +} + +/// Response after attempting to subscribe to a contract from a delegate. +/// +/// Note: This confirms subscription registration only. Actual notification +/// delivery to the delegate when the contract updates is not yet implemented +/// and will require the async delegate v2 API. +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct SubscribeContractResponse { + /// The contract subscribed to. + pub contract_id: ContractInstanceId, + /// Success (Ok) or error message (Err). + pub result: Result<(), String>, + /// Context for the delegate. + pub context: DelegateContext, +} + #[serde_as] #[derive(Serialize, Deserialize, Debug, Clone)] pub struct NotificationMessage<'a>( diff --git a/rust/src/generated/client_request_generated.rs b/rust/src/generated/client_request_generated.rs index 5b0ff26..2540ed1 100644 --- a/rust/src/generated/client_request_generated.rs +++ b/rust/src/generated/client_request_generated.rs @@ -1,13 +1,23 @@ // automatically generated by the FlatBuffers compiler, do not modify + // @generated -extern crate alloc; use crate::common_generated::*; +use core::cmp::Ordering; +use core::mem; + +extern crate flatbuffers; +use self::flatbuffers::{EndianScalar, Follow}; #[allow(unused_imports, dead_code)] pub mod client_request { use crate::common_generated::*; + use core::cmp::Ordering; + use core::mem; + + extern crate flatbuffers; + use self::flatbuffers::{EndianScalar, Follow}; #[deprecated( since = "2.0.0", @@ -47,8 +57,8 @@ pub mod client_request { } } } - impl ::core::fmt::Debug for DelegateType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for DelegateType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -56,24 +66,24 @@ pub mod client_request { } } } - impl<'a> ::flatbuffers::Follow<'a> for DelegateType { + impl<'a> flatbuffers::Follow<'a> for DelegateType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for DelegateType { + impl flatbuffers::Push for DelegateType { type Output = DelegateType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for DelegateType { + impl flatbuffers::EndianScalar for DelegateType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -87,17 +97,18 @@ pub mod client_request { } } - impl<'a> ::flatbuffers::Verifiable for DelegateType { + impl<'a> flatbuffers::Verifiable for DelegateType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for DelegateType {} + impl flatbuffers::SimpleToVerifyInSlice for DelegateType {} pub struct DelegateTypeUnionTableOffset {} #[deprecated( @@ -155,8 +166,8 @@ pub mod client_request { } } } - impl ::core::fmt::Debug for ContractRequestType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for ContractRequestType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -164,24 +175,24 @@ pub mod client_request { } } } - impl<'a> ::flatbuffers::Follow<'a> for ContractRequestType { + impl<'a> flatbuffers::Follow<'a> for ContractRequestType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for ContractRequestType { + impl flatbuffers::Push for ContractRequestType { type Output = ContractRequestType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for ContractRequestType { + impl flatbuffers::EndianScalar for ContractRequestType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -195,17 +206,18 @@ pub mod client_request { } } - impl<'a> ::flatbuffers::Verifiable for ContractRequestType { + impl<'a> flatbuffers::Verifiable for ContractRequestType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for ContractRequestType {} + impl flatbuffers::SimpleToVerifyInSlice for ContractRequestType {} pub struct ContractRequestTypeUnionTableOffset {} #[deprecated( @@ -255,8 +267,8 @@ pub mod client_request { } } } - impl ::core::fmt::Debug for InboundDelegateMsgType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for InboundDelegateMsgType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -264,24 +276,24 @@ pub mod client_request { } } } - impl<'a> ::flatbuffers::Follow<'a> for InboundDelegateMsgType { + impl<'a> flatbuffers::Follow<'a> for InboundDelegateMsgType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for InboundDelegateMsgType { + impl flatbuffers::Push for InboundDelegateMsgType { type Output = InboundDelegateMsgType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for InboundDelegateMsgType { + impl flatbuffers::EndianScalar for InboundDelegateMsgType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -295,17 +307,18 @@ pub mod client_request { } } - impl<'a> ::flatbuffers::Verifiable for InboundDelegateMsgType { + impl<'a> flatbuffers::Verifiable for InboundDelegateMsgType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for InboundDelegateMsgType {} + impl flatbuffers::SimpleToVerifyInSlice for InboundDelegateMsgType {} pub struct InboundDelegateMsgTypeUnionTableOffset {} #[deprecated( @@ -359,8 +372,8 @@ pub mod client_request { } } } - impl ::core::fmt::Debug for DelegateRequestType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for DelegateRequestType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -368,24 +381,24 @@ pub mod client_request { } } } - impl<'a> ::flatbuffers::Follow<'a> for DelegateRequestType { + impl<'a> flatbuffers::Follow<'a> for DelegateRequestType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for DelegateRequestType { + impl flatbuffers::Push for DelegateRequestType { type Output = DelegateRequestType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for DelegateRequestType { + impl flatbuffers::EndianScalar for DelegateRequestType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -399,17 +412,18 @@ pub mod client_request { } } - impl<'a> ::flatbuffers::Verifiable for DelegateRequestType { + impl<'a> flatbuffers::Verifiable for DelegateRequestType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for DelegateRequestType {} + impl flatbuffers::SimpleToVerifyInSlice for DelegateRequestType {} pub struct DelegateRequestTypeUnionTableOffset {} #[deprecated( @@ -467,8 +481,8 @@ pub mod client_request { } } } - impl ::core::fmt::Debug for ClientRequestType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for ClientRequestType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -476,24 +490,24 @@ pub mod client_request { } } } - impl<'a> ::flatbuffers::Follow<'a> for ClientRequestType { + impl<'a> flatbuffers::Follow<'a> for ClientRequestType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for ClientRequestType { + impl flatbuffers::Push for ClientRequestType { type Output = ClientRequestType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for ClientRequestType { + impl flatbuffers::EndianScalar for ClientRequestType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -507,42 +521,43 @@ pub mod client_request { } } - impl<'a> ::flatbuffers::Verifiable for ClientRequestType { + impl<'a> flatbuffers::Verifiable for ClientRequestType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for ClientRequestType {} + impl flatbuffers::SimpleToVerifyInSlice for ClientRequestType {} pub struct ClientRequestTypeUnionTableOffset {} pub enum DelegateCodeOffset {} #[derive(Copy, Clone, PartialEq)] pub struct DelegateCode<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for DelegateCode<'a> { + impl<'a> flatbuffers::Follow<'a> for DelegateCode<'a> { type Inner = DelegateCode<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> DelegateCode<'a> { - pub const VT_DATA: ::flatbuffers::VOffsetT = 4; - pub const VT_CODE_HASH: ::flatbuffers::VOffsetT = 6; + pub const VT_DATA: flatbuffers::VOffsetT = 4; + pub const VT_CODE_HASH: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { DelegateCode { _tab: table } } #[allow(unused_mut)] @@ -550,11 +565,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args DelegateCodeArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = DelegateCodeBuilder::new(_fbb); if let Some(x) = args.code_hash { builder.add_code_hash(x); @@ -566,13 +581,13 @@ pub mod client_request { } #[inline] - pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn data(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( DelegateCode::VT_DATA, None, ) @@ -580,13 +595,13 @@ pub mod client_request { } } #[inline] - pub fn code_hash(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn code_hash(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( DelegateCode::VT_CODE_HASH, None, ) @@ -595,19 +610,20 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for DelegateCode<'_> { + impl flatbuffers::Verifiable for DelegateCode<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "data", Self::VT_DATA, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "code_hash", Self::VT_CODE_HASH, true, @@ -617,8 +633,8 @@ pub mod client_request { } } pub struct DelegateCodeArgs<'a> { - pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub code_hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub data: Option>>, + pub code_hash: Option>>, } impl<'a> Default for DelegateCodeArgs<'a> { #[inline] @@ -630,29 +646,29 @@ pub mod client_request { } } - pub struct DelegateCodeBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct DelegateCodeBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateCodeBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> DelegateCodeBuilder<'a, 'b, A> { #[inline] - pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(DelegateCode::VT_DATA, data); + .push_slot_always::>(DelegateCode::VT_DATA, data); } #[inline] pub fn add_code_hash( &mut self, - code_hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + code_hash: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( DelegateCode::VT_CODE_HASH, code_hash, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> DelegateCodeBuilder<'a, 'b, A> { let start = _fbb.start_table(); DelegateCodeBuilder { @@ -661,17 +677,17 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, DelegateCode::VT_DATA, "data"); self.fbb_ .required(o, DelegateCode::VT_CODE_HASH, "code_hash"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for DelegateCode<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for DelegateCode<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("DelegateCode"); ds.field("data", &self.data()); ds.field("code_hash", &self.code_hash()); @@ -682,25 +698,25 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct DelegateKey<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for DelegateKey<'a> { + impl<'a> flatbuffers::Follow<'a> for DelegateKey<'a> { type Inner = DelegateKey<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> DelegateKey<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_CODE_HASH: ::flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_CODE_HASH: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { DelegateKey { _tab: table } } #[allow(unused_mut)] @@ -708,11 +724,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args DelegateKeyArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = DelegateKeyBuilder::new(_fbb); if let Some(x) = args.code_hash { builder.add_code_hash(x); @@ -724,13 +740,13 @@ pub mod client_request { } #[inline] - pub fn key(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn key(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( DelegateKey::VT_KEY, None, ) @@ -738,13 +754,13 @@ pub mod client_request { } } #[inline] - pub fn code_hash(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn code_hash(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( DelegateKey::VT_CODE_HASH, None, ) @@ -753,19 +769,20 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for DelegateKey<'_> { + impl flatbuffers::Verifiable for DelegateKey<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "code_hash", Self::VT_CODE_HASH, true, @@ -775,8 +792,8 @@ pub mod client_request { } } pub struct DelegateKeyArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub code_hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub key: Option>>, + pub code_hash: Option>>, } impl<'a> Default for DelegateKeyArgs<'a> { #[inline] @@ -788,29 +805,29 @@ pub mod client_request { } } - pub struct DelegateKeyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct DelegateKeyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateKeyBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> DelegateKeyBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(DelegateKey::VT_KEY, key); + .push_slot_always::>(DelegateKey::VT_KEY, key); } #[inline] pub fn add_code_hash( &mut self, - code_hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + code_hash: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( DelegateKey::VT_CODE_HASH, code_hash, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> DelegateKeyBuilder<'a, 'b, A> { let start = _fbb.start_table(); DelegateKeyBuilder { @@ -819,17 +836,17 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, DelegateKey::VT_KEY, "key"); self.fbb_ .required(o, DelegateKey::VT_CODE_HASH, "code_hash"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for DelegateKey<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for DelegateKey<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("DelegateKey"); ds.field("key", &self.key()); ds.field("code_hash", &self.code_hash()); @@ -840,24 +857,24 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct DelegateContext<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for DelegateContext<'a> { + impl<'a> flatbuffers::Follow<'a> for DelegateContext<'a> { type Inner = DelegateContext<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> DelegateContext<'a> { - pub const VT_DATA: ::flatbuffers::VOffsetT = 4; + pub const VT_DATA: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { DelegateContext { _tab: table } } #[allow(unused_mut)] @@ -865,11 +882,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args DelegateContextArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = DelegateContextBuilder::new(_fbb); if let Some(x) = args.data { builder.add_data(x); @@ -878,13 +895,13 @@ pub mod client_request { } #[inline] - pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn data(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( DelegateContext::VT_DATA, None, ) @@ -893,14 +910,15 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for DelegateContext<'_> { + impl flatbuffers::Verifiable for DelegateContext<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "data", Self::VT_DATA, true, @@ -910,7 +928,7 @@ pub mod client_request { } } pub struct DelegateContextArgs<'a> { - pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub data: Option>>, } impl<'a> Default for DelegateContextArgs<'a> { #[inline] @@ -921,19 +939,19 @@ pub mod client_request { } } - pub struct DelegateContextBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct DelegateContextBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateContextBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> DelegateContextBuilder<'a, 'b, A> { #[inline] - pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(DelegateContext::VT_DATA, data); + .push_slot_always::>(DelegateContext::VT_DATA, data); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> DelegateContextBuilder<'a, 'b, A> { let start = _fbb.start_table(); DelegateContextBuilder { @@ -942,15 +960,15 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, DelegateContext::VT_DATA, "data"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for DelegateContext<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for DelegateContext<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("DelegateContext"); ds.field("data", &self.data()); ds.finish() @@ -960,26 +978,26 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct WasmDelegateV1<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for WasmDelegateV1<'a> { + impl<'a> flatbuffers::Follow<'a> for WasmDelegateV1<'a> { type Inner = WasmDelegateV1<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> WasmDelegateV1<'a> { - pub const VT_PARAMETERS: ::flatbuffers::VOffsetT = 4; - pub const VT_DATA: ::flatbuffers::VOffsetT = 6; - pub const VT_KEY: ::flatbuffers::VOffsetT = 8; + pub const VT_PARAMETERS: flatbuffers::VOffsetT = 4; + pub const VT_DATA: flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { WasmDelegateV1 { _tab: table } } #[allow(unused_mut)] @@ -987,11 +1005,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args WasmDelegateV1Args<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = WasmDelegateV1Builder::new(_fbb); if let Some(x) = args.key { builder.add_key(x); @@ -1006,13 +1024,13 @@ pub mod client_request { } #[inline] - pub fn parameters(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn parameters(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( WasmDelegateV1::VT_PARAMETERS, None, ) @@ -1026,7 +1044,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( WasmDelegateV1::VT_DATA, None, ) @@ -1040,33 +1058,31 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( - WasmDelegateV1::VT_KEY, - None, - ) + .get::>(WasmDelegateV1::VT_KEY, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for WasmDelegateV1<'_> { + impl flatbuffers::Verifiable for WasmDelegateV1<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "parameters", Self::VT_PARAMETERS, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "data", Self::VT_DATA, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, @@ -1076,9 +1092,9 @@ pub mod client_request { } } pub struct WasmDelegateV1Args<'a> { - pub parameters: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub data: Option<::flatbuffers::WIPOffset>>, - pub key: Option<::flatbuffers::WIPOffset>>, + pub parameters: Option>>, + pub data: Option>>, + pub key: Option>>, } impl<'a> Default for WasmDelegateV1Args<'a> { #[inline] @@ -1091,40 +1107,40 @@ pub mod client_request { } } - pub struct WasmDelegateV1Builder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct WasmDelegateV1Builder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WasmDelegateV1Builder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> WasmDelegateV1Builder<'a, 'b, A> { #[inline] pub fn add_parameters( &mut self, - parameters: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + parameters: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( WasmDelegateV1::VT_PARAMETERS, parameters, ); } #[inline] - pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset>) { + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( WasmDelegateV1::VT_DATA, data, ); } #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( WasmDelegateV1::VT_KEY, key, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> WasmDelegateV1Builder<'a, 'b, A> { let start = _fbb.start_table(); WasmDelegateV1Builder { @@ -1133,18 +1149,18 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, WasmDelegateV1::VT_PARAMETERS, "parameters"); self.fbb_.required(o, WasmDelegateV1::VT_DATA, "data"); self.fbb_.required(o, WasmDelegateV1::VT_KEY, "key"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for WasmDelegateV1<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for WasmDelegateV1<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("WasmDelegateV1"); ds.field("parameters", &self.parameters()); ds.field("data", &self.data()); @@ -1156,25 +1172,25 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct DelegateContainer<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for DelegateContainer<'a> { + impl<'a> flatbuffers::Follow<'a> for DelegateContainer<'a> { type Inner = DelegateContainer<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> DelegateContainer<'a> { - pub const VT_DELEGATE_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_DELEGATE: ::flatbuffers::VOffsetT = 6; + pub const VT_DELEGATE_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_DELEGATE: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { DelegateContainer { _tab: table } } #[allow(unused_mut)] @@ -1182,11 +1198,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args DelegateContainerArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = DelegateContainerBuilder::new(_fbb); if let Some(x) = args.delegate { builder.add_delegate(x); @@ -1210,13 +1226,13 @@ pub mod client_request { } } #[inline] - pub fn delegate(&self) -> ::flatbuffers::Table<'a> { + pub fn delegate(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( DelegateContainer::VT_DELEGATE, None, ) @@ -1238,12 +1254,13 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for DelegateContainer<'_> { + impl flatbuffers::Verifiable for DelegateContainer<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_union::( "delegate_type", @@ -1253,7 +1270,7 @@ pub mod client_request { true, |key, v, pos| match key { DelegateType::WasmDelegateV1 => v - .verify_union_variant::<::flatbuffers::ForwardsUOffset>( + .verify_union_variant::>( "DelegateType::WasmDelegateV1", pos, ), @@ -1266,7 +1283,7 @@ pub mod client_request { } pub struct DelegateContainerArgs { pub delegate_type: DelegateType, - pub delegate: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub delegate: Option>, } impl<'a> Default for DelegateContainerArgs { #[inline] @@ -1278,11 +1295,11 @@ pub mod client_request { } } - pub struct DelegateContainerBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct DelegateContainerBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateContainerBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> DelegateContainerBuilder<'a, 'b, A> { #[inline] pub fn add_delegate_type(&mut self, delegate_type: DelegateType) { self.fbb_.push_slot::( @@ -1294,16 +1311,16 @@ pub mod client_request { #[inline] pub fn add_delegate( &mut self, - delegate: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + delegate: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( DelegateContainer::VT_DELEGATE, delegate, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> DelegateContainerBuilder<'a, 'b, A> { let start = _fbb.start_table(); DelegateContainerBuilder { @@ -1312,16 +1329,16 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, DelegateContainer::VT_DELEGATE, "delegate"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for DelegateContainer<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for DelegateContainer<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("DelegateContainer"); ds.field("delegate_type", &self.delegate_type()); match self.delegate_type() { @@ -1347,25 +1364,25 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct RelatedContract<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for RelatedContract<'a> { + impl<'a> flatbuffers::Follow<'a> for RelatedContract<'a> { type Inner = RelatedContract<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> RelatedContract<'a> { - pub const VT_INSTANCE_ID: ::flatbuffers::VOffsetT = 4; - pub const VT_STATE: ::flatbuffers::VOffsetT = 6; + pub const VT_INSTANCE_ID: flatbuffers::VOffsetT = 4; + pub const VT_STATE: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { RelatedContract { _tab: table } } #[allow(unused_mut)] @@ -1373,11 +1390,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args RelatedContractArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = RelatedContractBuilder::new(_fbb); if let Some(x) = args.state { builder.add_state(x); @@ -1395,7 +1412,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( RelatedContract::VT_INSTANCE_ID, None, ) @@ -1403,13 +1420,13 @@ pub mod client_request { } } #[inline] - pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn state(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( RelatedContract::VT_STATE, None, ) @@ -1418,19 +1435,20 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for RelatedContract<'_> { + impl flatbuffers::Verifiable for RelatedContract<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "instance_id", Self::VT_INSTANCE_ID, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "state", Self::VT_STATE, true, @@ -1440,8 +1458,8 @@ pub mod client_request { } } pub struct RelatedContractArgs<'a> { - pub instance_id: Option<::flatbuffers::WIPOffset>>, - pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub instance_id: Option>>, + pub state: Option>>, } impl<'a> Default for RelatedContractArgs<'a> { #[inline] @@ -1453,33 +1471,30 @@ pub mod client_request { } } - pub struct RelatedContractBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct RelatedContractBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedContractBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> RelatedContractBuilder<'a, 'b, A> { #[inline] pub fn add_instance_id( &mut self, - instance_id: ::flatbuffers::WIPOffset>, + instance_id: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( RelatedContract::VT_INSTANCE_ID, instance_id, ); } #[inline] - pub fn add_state( - &mut self, - state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { + pub fn add_state(&mut self, state: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(RelatedContract::VT_STATE, state); + .push_slot_always::>(RelatedContract::VT_STATE, state); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> RelatedContractBuilder<'a, 'b, A> { let start = _fbb.start_table(); RelatedContractBuilder { @@ -1488,17 +1503,17 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, RelatedContract::VT_INSTANCE_ID, "instance_id"); self.fbb_.required(o, RelatedContract::VT_STATE, "state"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for RelatedContract<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for RelatedContract<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("RelatedContract"); ds.field("instance_id", &self.instance_id()); ds.field("state", &self.state()); @@ -1509,24 +1524,24 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct RelatedContracts<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for RelatedContracts<'a> { + impl<'a> flatbuffers::Follow<'a> for RelatedContracts<'a> { type Inner = RelatedContracts<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> RelatedContracts<'a> { - pub const VT_CONTRACTS: ::flatbuffers::VOffsetT = 4; + pub const VT_CONTRACTS: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { RelatedContracts { _tab: table } } #[allow(unused_mut)] @@ -1534,11 +1549,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args RelatedContractsArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = RelatedContractsBuilder::new(_fbb); if let Some(x) = args.contracts { builder.add_contracts(x); @@ -1549,30 +1564,30 @@ pub mod client_request { #[inline] pub fn contracts( &self, - ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>> - { + ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>, + .get::>, >>(RelatedContracts::VT_CONTRACTS, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for RelatedContracts<'_> { + impl flatbuffers::Verifiable for RelatedContracts<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>, + .visit_field::>, >>("contracts", Self::VT_CONTRACTS, true)? .finish(); Ok(()) @@ -1580,8 +1595,8 @@ pub mod client_request { } pub struct RelatedContractsArgs<'a> { pub contracts: Option< - ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>, + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, >, >, } @@ -1594,26 +1609,26 @@ pub mod client_request { } } - pub struct RelatedContractsBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct RelatedContractsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedContractsBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> RelatedContractsBuilder<'a, 'b, A> { #[inline] pub fn add_contracts( &mut self, - contracts: ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset>>, + contracts: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, >, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( RelatedContracts::VT_CONTRACTS, contracts, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> RelatedContractsBuilder<'a, 'b, A> { let start = _fbb.start_table(); RelatedContractsBuilder { @@ -1622,16 +1637,16 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, RelatedContracts::VT_CONTRACTS, "contracts"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for RelatedContracts<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for RelatedContracts<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("RelatedContracts"); ds.field("contracts", &self.contracts()); ds.finish() @@ -1641,28 +1656,28 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct Put<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for Put<'a> { + impl<'a> flatbuffers::Follow<'a> for Put<'a> { type Inner = Put<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> Put<'a> { - pub const VT_CONTAINER: ::flatbuffers::VOffsetT = 4; - pub const VT_WRAPPED_STATE: ::flatbuffers::VOffsetT = 6; - pub const VT_RELATED_CONTRACTS: ::flatbuffers::VOffsetT = 8; - pub const VT_SUBSCRIBE: ::flatbuffers::VOffsetT = 10; - pub const VT_BLOCKING_SUBSCRIBE: ::flatbuffers::VOffsetT = 12; + pub const VT_CONTAINER: flatbuffers::VOffsetT = 4; + pub const VT_WRAPPED_STATE: flatbuffers::VOffsetT = 6; + pub const VT_RELATED_CONTRACTS: flatbuffers::VOffsetT = 8; + pub const VT_SUBSCRIBE: flatbuffers::VOffsetT = 10; + pub const VT_BLOCKING_SUBSCRIBE: flatbuffers::VOffsetT = 12; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Put { _tab: table } } #[allow(unused_mut)] @@ -1670,11 +1685,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args PutArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = PutBuilder::new(_fbb); if let Some(x) = args.related_contracts { builder.add_related_contracts(x); @@ -1697,7 +1712,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( Put::VT_CONTAINER, None, ) @@ -1705,13 +1720,13 @@ pub mod client_request { } } #[inline] - pub fn wrapped_state(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn wrapped_state(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( Put::VT_WRAPPED_STATE, None, ) @@ -1725,7 +1740,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( Put::VT_RELATED_CONTRACTS, None, ) @@ -1756,24 +1771,25 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for Put<'_> { + impl flatbuffers::Verifiable for Put<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "container", Self::VT_CONTAINER, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "wrapped_state", Self::VT_WRAPPED_STATE, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "related_contracts", Self::VT_RELATED_CONTRACTS, true, @@ -1785,9 +1801,9 @@ pub mod client_request { } } pub struct PutArgs<'a> { - pub container: Option<::flatbuffers::WIPOffset>>, - pub wrapped_state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub related_contracts: Option<::flatbuffers::WIPOffset>>, + pub container: Option>>, + pub wrapped_state: Option>>, + pub related_contracts: Option>>, pub subscribe: bool, pub blocking_subscribe: bool, } @@ -1804,18 +1820,18 @@ pub mod client_request { } } - pub struct PutBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct PutBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PutBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> PutBuilder<'a, 'b, A> { #[inline] pub fn add_container( &mut self, - container: ::flatbuffers::WIPOffset>, + container: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( Put::VT_CONTAINER, container, ); @@ -1823,9 +1839,9 @@ pub mod client_request { #[inline] pub fn add_wrapped_state( &mut self, - wrapped_state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + wrapped_state: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( Put::VT_WRAPPED_STATE, wrapped_state, ); @@ -1833,10 +1849,10 @@ pub mod client_request { #[inline] pub fn add_related_contracts( &mut self, - related_contracts: ::flatbuffers::WIPOffset>, + related_contracts: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( Put::VT_RELATED_CONTRACTS, related_contracts, ); @@ -1852,7 +1868,7 @@ pub mod client_request { .push_slot::(Put::VT_BLOCKING_SUBSCRIBE, blocking_subscribe, false); } #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PutBuilder<'a, 'b, A> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PutBuilder<'a, 'b, A> { let start = _fbb.start_table(); PutBuilder { fbb_: _fbb, @@ -1860,19 +1876,19 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, Put::VT_CONTAINER, "container"); self.fbb_ .required(o, Put::VT_WRAPPED_STATE, "wrapped_state"); self.fbb_ .required(o, Put::VT_RELATED_CONTRACTS, "related_contracts"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for Put<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for Put<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("Put"); ds.field("container", &self.container()); ds.field("wrapped_state", &self.wrapped_state()); @@ -1886,25 +1902,25 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct Update<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for Update<'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) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> Update<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_DATA: ::flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_DATA: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Update { _tab: table } } #[allow(unused_mut)] @@ -1912,11 +1928,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args UpdateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = UpdateBuilder::new(_fbb); if let Some(x) = args.data { builder.add_data(x); @@ -1934,7 +1950,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( Update::VT_KEY, None, ) @@ -1948,7 +1964,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( Update::VT_DATA, None, ) @@ -1957,19 +1973,20 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for Update<'_> { + impl flatbuffers::Verifiable for Update<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "data", Self::VT_DATA, true, @@ -1979,8 +1996,8 @@ pub mod client_request { } } pub struct UpdateArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, - pub data: Option<::flatbuffers::WIPOffset>>, + pub key: Option>>, + pub data: Option>>, } impl<'a> Default for UpdateArgs<'a> { #[inline] @@ -1992,30 +2009,30 @@ pub mod client_request { } } - pub struct UpdateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct UpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UpdateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> UpdateBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( Update::VT_KEY, key, ); } #[inline] - pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset>) { + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( Update::VT_DATA, data, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> UpdateBuilder<'a, 'b, A> { let start = _fbb.start_table(); UpdateBuilder { @@ -2024,16 +2041,16 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, Update::VT_KEY, "key"); self.fbb_.required(o, Update::VT_DATA, "data"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for Update<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + 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("key", &self.key()); ds.field("data", &self.data()); @@ -2044,27 +2061,27 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct Get<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for Get<'a> { + impl<'a> flatbuffers::Follow<'a> for Get<'a> { type Inner = Get<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> Get<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_FETCH_CONTRACT: ::flatbuffers::VOffsetT = 6; - pub const VT_SUBSCRIBE: ::flatbuffers::VOffsetT = 8; - pub const VT_BLOCKING_SUBSCRIBE: ::flatbuffers::VOffsetT = 10; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_FETCH_CONTRACT: flatbuffers::VOffsetT = 6; + pub const VT_SUBSCRIBE: flatbuffers::VOffsetT = 8; + pub const VT_BLOCKING_SUBSCRIBE: flatbuffers::VOffsetT = 10; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Get { _tab: table } } #[allow(unused_mut)] @@ -2072,11 +2089,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args GetArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = GetBuilder::new(_fbb); if let Some(x) = args.key { builder.add_key(x); @@ -2094,7 +2111,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( Get::VT_KEY, None, ) @@ -2136,14 +2153,15 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for Get<'_> { + impl flatbuffers::Verifiable for Get<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, @@ -2156,7 +2174,7 @@ pub mod client_request { } } pub struct GetArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, + pub key: Option>>, pub fetch_contract: bool, pub subscribe: bool, pub blocking_subscribe: bool, @@ -2173,15 +2191,15 @@ pub mod client_request { } } - pub struct GetBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct GetBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GetBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> GetBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( Get::VT_KEY, key, ); @@ -2202,7 +2220,7 @@ pub mod client_request { .push_slot::(Get::VT_BLOCKING_SUBSCRIBE, blocking_subscribe, false); } #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GetBuilder<'a, 'b, A> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> GetBuilder<'a, 'b, A> { let start = _fbb.start_table(); GetBuilder { fbb_: _fbb, @@ -2210,15 +2228,15 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, Get::VT_KEY, "key"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for Get<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for Get<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("Get"); ds.field("key", &self.key()); ds.field("fetch_contract", &self.fetch_contract()); @@ -2231,25 +2249,25 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct Subscribe<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for Subscribe<'a> { + impl<'a> flatbuffers::Follow<'a> for Subscribe<'a> { type Inner = Subscribe<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> Subscribe<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_SUMMARY: ::flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_SUMMARY: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Subscribe { _tab: table } } #[allow(unused_mut)] @@ -2257,11 +2275,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args SubscribeArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = SubscribeBuilder::new(_fbb); if let Some(x) = args.summary { builder.add_summary(x); @@ -2279,7 +2297,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( Subscribe::VT_KEY, None, ) @@ -2287,13 +2305,13 @@ pub mod client_request { } } #[inline] - pub fn summary(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + pub fn summary(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( Subscribe::VT_SUMMARY, None, ) @@ -2301,19 +2319,20 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for Subscribe<'_> { + impl flatbuffers::Verifiable for Subscribe<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "summary", Self::VT_SUMMARY, false, @@ -2323,8 +2342,8 @@ pub mod client_request { } } pub struct SubscribeArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, - pub summary: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub key: Option>>, + pub summary: Option>>, } impl<'a> Default for SubscribeArgs<'a> { #[inline] @@ -2336,15 +2355,15 @@ pub mod client_request { } } - pub struct SubscribeBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct SubscribeBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SubscribeBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> SubscribeBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( Subscribe::VT_KEY, key, ); @@ -2352,14 +2371,14 @@ pub mod client_request { #[inline] pub fn add_summary( &mut self, - summary: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + summary: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(Subscribe::VT_SUMMARY, summary); + .push_slot_always::>(Subscribe::VT_SUMMARY, summary); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> SubscribeBuilder<'a, 'b, A> { let start = _fbb.start_table(); SubscribeBuilder { @@ -2368,15 +2387,15 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, Subscribe::VT_KEY, "key"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for Subscribe<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for Subscribe<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("Subscribe"); ds.field("key", &self.key()); ds.field("summary", &self.summary()); @@ -2387,24 +2406,24 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct ClientResponse<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ClientResponse<'a> { + impl<'a> flatbuffers::Follow<'a> for ClientResponse<'a> { type Inner = ClientResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ClientResponse<'a> { - pub const VT_DATA: ::flatbuffers::VOffsetT = 4; + pub const VT_DATA: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ClientResponse { _tab: table } } #[allow(unused_mut)] @@ -2412,11 +2431,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ClientResponseArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ClientResponseBuilder::new(_fbb); if let Some(x) = args.data { builder.add_data(x); @@ -2425,13 +2444,13 @@ pub mod client_request { } #[inline] - pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn data(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ClientResponse::VT_DATA, None, ) @@ -2440,14 +2459,15 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for ClientResponse<'_> { + impl flatbuffers::Verifiable for ClientResponse<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "data", Self::VT_DATA, true, @@ -2457,7 +2477,7 @@ pub mod client_request { } } pub struct ClientResponseArgs<'a> { - pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub data: Option>>, } impl<'a> Default for ClientResponseArgs<'a> { #[inline] @@ -2468,19 +2488,19 @@ pub mod client_request { } } - pub struct ClientResponseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ClientResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ClientResponseBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ClientResponseBuilder<'a, 'b, A> { #[inline] - pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(ClientResponse::VT_DATA, data); + .push_slot_always::>(ClientResponse::VT_DATA, data); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ClientResponseBuilder<'a, 'b, A> { let start = _fbb.start_table(); ClientResponseBuilder { @@ -2489,15 +2509,15 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, ClientResponse::VT_DATA, "data"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ClientResponse<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ClientResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ClientResponse"); ds.field("data", &self.data()); ds.finish() @@ -2507,26 +2527,26 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct UserInputResponse<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for UserInputResponse<'a> { + impl<'a> flatbuffers::Follow<'a> for UserInputResponse<'a> { type Inner = UserInputResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> UserInputResponse<'a> { - pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 4; - pub const VT_RESPONSE: ::flatbuffers::VOffsetT = 6; - pub const VT_DELEGATE_CONTEXT: ::flatbuffers::VOffsetT = 8; + pub const VT_REQUEST_ID: flatbuffers::VOffsetT = 4; + pub const VT_RESPONSE: flatbuffers::VOffsetT = 6; + pub const VT_DELEGATE_CONTEXT: flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { UserInputResponse { _tab: table } } #[allow(unused_mut)] @@ -2534,11 +2554,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args UserInputResponseArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = UserInputResponseBuilder::new(_fbb); if let Some(x) = args.delegate_context { builder.add_delegate_context(x); @@ -2568,7 +2588,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( UserInputResponse::VT_RESPONSE, None, ) @@ -2576,13 +2596,13 @@ pub mod client_request { } } #[inline] - pub fn delegate_context(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn delegate_context(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( UserInputResponse::VT_DELEGATE_CONTEXT, None, ) @@ -2591,20 +2611,21 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for UserInputResponse<'_> { + impl flatbuffers::Verifiable for UserInputResponse<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::("request_id", Self::VT_REQUEST_ID, false)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "response", Self::VT_RESPONSE, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "delegate_context", Self::VT_DELEGATE_CONTEXT, true, @@ -2615,8 +2636,8 @@ pub mod client_request { } pub struct UserInputResponseArgs<'a> { pub request_id: u32, - pub response: Option<::flatbuffers::WIPOffset>>, - pub delegate_context: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub response: Option>>, + pub delegate_context: Option>>, } impl<'a> Default for UserInputResponseArgs<'a> { #[inline] @@ -2629,20 +2650,20 @@ pub mod client_request { } } - pub struct UserInputResponseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct UserInputResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UserInputResponseBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> UserInputResponseBuilder<'a, 'b, A> { #[inline] pub fn add_request_id(&mut self, request_id: u32) { self.fbb_ .push_slot::(UserInputResponse::VT_REQUEST_ID, request_id, 0); } #[inline] - pub fn add_response(&mut self, response: ::flatbuffers::WIPOffset>) { + pub fn add_response(&mut self, response: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( UserInputResponse::VT_RESPONSE, response, ); @@ -2650,16 +2671,16 @@ pub mod client_request { #[inline] pub fn add_delegate_context( &mut self, - delegate_context: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + delegate_context: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( UserInputResponse::VT_DELEGATE_CONTEXT, delegate_context, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> UserInputResponseBuilder<'a, 'b, A> { let start = _fbb.start_table(); UserInputResponseBuilder { @@ -2668,7 +2689,7 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, UserInputResponse::VT_RESPONSE, "response"); @@ -2677,12 +2698,12 @@ pub mod client_request { UserInputResponse::VT_DELEGATE_CONTEXT, "delegate_context", ); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for UserInputResponse<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for UserInputResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("UserInputResponse"); ds.field("request_id", &self.request_id()); ds.field("response", &self.response()); @@ -2694,25 +2715,25 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct InboundDelegateMsg<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for InboundDelegateMsg<'a> { + impl<'a> flatbuffers::Follow<'a> for InboundDelegateMsg<'a> { type Inner = InboundDelegateMsg<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> InboundDelegateMsg<'a> { - pub const VT_INBOUND_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_INBOUND: ::flatbuffers::VOffsetT = 6; + pub const VT_INBOUND_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_INBOUND: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { InboundDelegateMsg { _tab: table } } #[allow(unused_mut)] @@ -2720,11 +2741,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args InboundDelegateMsgArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = InboundDelegateMsgBuilder::new(_fbb); if let Some(x) = args.inbound { builder.add_inbound(x); @@ -2748,13 +2769,13 @@ pub mod client_request { } } #[inline] - pub fn inbound(&self) -> ::flatbuffers::Table<'a> { + pub fn inbound(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( InboundDelegateMsg::VT_INBOUND, None, ) @@ -2792,17 +2813,18 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for InboundDelegateMsg<'_> { + impl flatbuffers::Verifiable for InboundDelegateMsg<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_union::("inbound_type", Self::VT_INBOUND_TYPE, "inbound", Self::VT_INBOUND, true, |key, v, pos| { match key { - InboundDelegateMsgType::common_ApplicationMessage => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("InboundDelegateMsgType::common_ApplicationMessage", pos), - InboundDelegateMsgType::UserInputResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("InboundDelegateMsgType::UserInputResponse", pos), + InboundDelegateMsgType::common_ApplicationMessage => v.verify_union_variant::>("InboundDelegateMsgType::common_ApplicationMessage", pos), + InboundDelegateMsgType::UserInputResponse => v.verify_union_variant::>("InboundDelegateMsgType::UserInputResponse", pos), _ => Ok(()), } })? @@ -2812,7 +2834,7 @@ pub mod client_request { } pub struct InboundDelegateMsgArgs { pub inbound_type: InboundDelegateMsgType, - pub inbound: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub inbound: Option>, } impl<'a> Default for InboundDelegateMsgArgs { #[inline] @@ -2824,11 +2846,11 @@ pub mod client_request { } } - pub struct InboundDelegateMsgBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct InboundDelegateMsgBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> InboundDelegateMsgBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> InboundDelegateMsgBuilder<'a, 'b, A> { #[inline] pub fn add_inbound_type(&mut self, inbound_type: InboundDelegateMsgType) { self.fbb_.push_slot::( @@ -2840,16 +2862,16 @@ pub mod client_request { #[inline] pub fn add_inbound( &mut self, - inbound: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + inbound: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( InboundDelegateMsg::VT_INBOUND, inbound, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> InboundDelegateMsgBuilder<'a, 'b, A> { let start = _fbb.start_table(); InboundDelegateMsgBuilder { @@ -2858,16 +2880,16 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, InboundDelegateMsg::VT_INBOUND, "inbound"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for InboundDelegateMsg<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for InboundDelegateMsg<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("InboundDelegateMsg"); ds.field("inbound_type", &self.inbound_type()); match self.inbound_type() { @@ -2903,26 +2925,26 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct ApplicationMessages<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ApplicationMessages<'a> { + impl<'a> flatbuffers::Follow<'a> for ApplicationMessages<'a> { type Inner = ApplicationMessages<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ApplicationMessages<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_PARAMS: ::flatbuffers::VOffsetT = 6; - pub const VT_INBOUND: ::flatbuffers::VOffsetT = 8; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_PARAMS: flatbuffers::VOffsetT = 6; + pub const VT_INBOUND: flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ApplicationMessages { _tab: table } } #[allow(unused_mut)] @@ -2930,11 +2952,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ApplicationMessagesArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ApplicationMessagesBuilder::new(_fbb); if let Some(x) = args.inbound { builder.add_inbound(x); @@ -2955,7 +2977,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( ApplicationMessages::VT_KEY, None, ) @@ -2963,13 +2985,13 @@ pub mod client_request { } } #[inline] - pub fn params(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn params(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ApplicationMessages::VT_PARAMS, None, ) @@ -2979,54 +3001,51 @@ pub mod client_request { #[inline] pub fn inbound( &self, - ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>> - { + ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector< - 'a, - ::flatbuffers::ForwardsUOffset, - >, + .get::>, >>(ApplicationMessages::VT_INBOUND, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for ApplicationMessages<'_> { + impl flatbuffers::Verifiable for ApplicationMessages<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "params", Self::VT_PARAMS, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>, + .visit_field::>, >>("inbound", Self::VT_INBOUND, true)? .finish(); Ok(()) } } pub struct ApplicationMessagesArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, - pub params: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub key: Option>>, + pub params: Option>>, pub inbound: Option< - ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>, + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, >, >, } @@ -3041,25 +3060,22 @@ pub mod client_request { } } - pub struct ApplicationMessagesBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ApplicationMessagesBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ApplicationMessagesBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ApplicationMessagesBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( ApplicationMessages::VT_KEY, key, ); } #[inline] - pub fn add_params( - &mut self, - params: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + pub fn add_params(&mut self, params: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>( ApplicationMessages::VT_PARAMS, params, ); @@ -3067,18 +3083,18 @@ pub mod client_request { #[inline] pub fn add_inbound( &mut self, - inbound: ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset>>, + inbound: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, >, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( ApplicationMessages::VT_INBOUND, inbound, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ApplicationMessagesBuilder<'a, 'b, A> { let start = _fbb.start_table(); ApplicationMessagesBuilder { @@ -3087,19 +3103,19 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, ApplicationMessages::VT_KEY, "key"); self.fbb_ .required(o, ApplicationMessages::VT_PARAMS, "params"); self.fbb_ .required(o, ApplicationMessages::VT_INBOUND, "inbound"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ApplicationMessages<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ApplicationMessages<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ApplicationMessages"); ds.field("key", &self.key()); ds.field("params", &self.params()); @@ -3111,26 +3127,26 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct RegisterDelegate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for RegisterDelegate<'a> { + impl<'a> flatbuffers::Follow<'a> for RegisterDelegate<'a> { type Inner = RegisterDelegate<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> RegisterDelegate<'a> { - pub const VT_DELEGATE: ::flatbuffers::VOffsetT = 4; - pub const VT_CIPHER: ::flatbuffers::VOffsetT = 6; - pub const VT_NONCE: ::flatbuffers::VOffsetT = 8; + pub const VT_DELEGATE: flatbuffers::VOffsetT = 4; + pub const VT_CIPHER: flatbuffers::VOffsetT = 6; + pub const VT_NONCE: flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { RegisterDelegate { _tab: table } } #[allow(unused_mut)] @@ -3138,11 +3154,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args RegisterDelegateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = RegisterDelegateBuilder::new(_fbb); if let Some(x) = args.nonce { builder.add_nonce(x); @@ -3163,7 +3179,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( RegisterDelegate::VT_DELEGATE, None, ) @@ -3171,13 +3187,13 @@ pub mod client_request { } } #[inline] - pub fn cipher(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn cipher(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( RegisterDelegate::VT_CIPHER, None, ) @@ -3185,13 +3201,13 @@ pub mod client_request { } } #[inline] - pub fn nonce(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn nonce(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( RegisterDelegate::VT_NONCE, None, ) @@ -3200,24 +3216,25 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for RegisterDelegate<'_> { + impl flatbuffers::Verifiable for RegisterDelegate<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "delegate", Self::VT_DELEGATE, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "cipher", Self::VT_CIPHER, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "nonce", Self::VT_NONCE, true, @@ -3227,9 +3244,9 @@ pub mod client_request { } } pub struct RegisterDelegateArgs<'a> { - pub delegate: Option<::flatbuffers::WIPOffset>>, - pub cipher: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub nonce: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub delegate: Option>>, + pub cipher: Option>>, + pub nonce: Option>>, } impl<'a> Default for RegisterDelegateArgs<'a> { #[inline] @@ -3242,40 +3259,32 @@ pub mod client_request { } } - pub struct RegisterDelegateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct RegisterDelegateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RegisterDelegateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> RegisterDelegateBuilder<'a, 'b, A> { #[inline] - pub fn add_delegate(&mut self, delegate: ::flatbuffers::WIPOffset>) { + pub fn add_delegate(&mut self, delegate: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( RegisterDelegate::VT_DELEGATE, delegate, ); } #[inline] - pub fn add_cipher( - &mut self, - cipher: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( - RegisterDelegate::VT_CIPHER, - cipher, - ); + pub fn add_cipher(&mut self, cipher: flatbuffers::WIPOffset>) { + self.fbb_ + .push_slot_always::>(RegisterDelegate::VT_CIPHER, cipher); } #[inline] - pub fn add_nonce( - &mut self, - nonce: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { + pub fn add_nonce(&mut self, nonce: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(RegisterDelegate::VT_NONCE, nonce); + .push_slot_always::>(RegisterDelegate::VT_NONCE, nonce); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> RegisterDelegateBuilder<'a, 'b, A> { let start = _fbb.start_table(); RegisterDelegateBuilder { @@ -3284,18 +3293,18 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, RegisterDelegate::VT_DELEGATE, "delegate"); self.fbb_.required(o, RegisterDelegate::VT_CIPHER, "cipher"); self.fbb_.required(o, RegisterDelegate::VT_NONCE, "nonce"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for RegisterDelegate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for RegisterDelegate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("RegisterDelegate"); ds.field("delegate", &self.delegate()); ds.field("cipher", &self.cipher()); @@ -3307,24 +3316,24 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct UnregisterDelegate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for UnregisterDelegate<'a> { + impl<'a> flatbuffers::Follow<'a> for UnregisterDelegate<'a> { type Inner = UnregisterDelegate<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> UnregisterDelegate<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; + pub const VT_KEY: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { UnregisterDelegate { _tab: table } } #[allow(unused_mut)] @@ -3332,11 +3341,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args UnregisterDelegateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = UnregisterDelegateBuilder::new(_fbb); if let Some(x) = args.key { builder.add_key(x); @@ -3351,7 +3360,7 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( UnregisterDelegate::VT_KEY, None, ) @@ -3360,14 +3369,15 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for UnregisterDelegate<'_> { + impl flatbuffers::Verifiable for UnregisterDelegate<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, @@ -3377,7 +3387,7 @@ pub mod client_request { } } pub struct UnregisterDelegateArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, + pub key: Option>>, } impl<'a> Default for UnregisterDelegateArgs<'a> { #[inline] @@ -3388,22 +3398,22 @@ pub mod client_request { } } - pub struct UnregisterDelegateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct UnregisterDelegateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UnregisterDelegateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> UnregisterDelegateBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( UnregisterDelegate::VT_KEY, key, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> UnregisterDelegateBuilder<'a, 'b, A> { let start = _fbb.start_table(); UnregisterDelegateBuilder { @@ -3412,15 +3422,15 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, UnregisterDelegate::VT_KEY, "key"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for UnregisterDelegate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for UnregisterDelegate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("UnregisterDelegate"); ds.field("key", &self.key()); ds.finish() @@ -3430,25 +3440,25 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct ContractRequest<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ContractRequest<'a> { + impl<'a> flatbuffers::Follow<'a> for ContractRequest<'a> { type Inner = ContractRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ContractRequest<'a> { - pub const VT_CONTRACT_REQUEST_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_CONTRACT_REQUEST: ::flatbuffers::VOffsetT = 6; + pub const VT_CONTRACT_REQUEST_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_CONTRACT_REQUEST: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ContractRequest { _tab: table } } #[allow(unused_mut)] @@ -3456,11 +3466,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ContractRequestArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ContractRequestBuilder::new(_fbb); if let Some(x) = args.contract_request { builder.add_contract_request(x); @@ -3484,13 +3494,13 @@ pub mod client_request { } } #[inline] - pub fn contract_request(&self) -> ::flatbuffers::Table<'a> { + pub fn contract_request(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( ContractRequest::VT_CONTRACT_REQUEST, None, ) @@ -3554,12 +3564,13 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for ContractRequest<'_> { + impl flatbuffers::Verifiable for ContractRequest<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_union::( "contract_request_type", @@ -3569,22 +3580,22 @@ pub mod client_request { true, |key, v, pos| match key { ContractRequestType::Put => v - .verify_union_variant::<::flatbuffers::ForwardsUOffset>( + .verify_union_variant::>( "ContractRequestType::Put", pos, ), ContractRequestType::Update => v - .verify_union_variant::<::flatbuffers::ForwardsUOffset>( + .verify_union_variant::>( "ContractRequestType::Update", pos, ), ContractRequestType::Get => v - .verify_union_variant::<::flatbuffers::ForwardsUOffset>( + .verify_union_variant::>( "ContractRequestType::Get", pos, ), ContractRequestType::Subscribe => v - .verify_union_variant::<::flatbuffers::ForwardsUOffset>( + .verify_union_variant::>( "ContractRequestType::Subscribe", pos, ), @@ -3597,7 +3608,7 @@ pub mod client_request { } pub struct ContractRequestArgs { pub contract_request_type: ContractRequestType, - pub contract_request: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub contract_request: Option>, } impl<'a> Default for ContractRequestArgs { #[inline] @@ -3609,11 +3620,11 @@ pub mod client_request { } } - pub struct ContractRequestBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ContractRequestBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractRequestBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ContractRequestBuilder<'a, 'b, A> { #[inline] pub fn add_contract_request_type(&mut self, contract_request_type: ContractRequestType) { self.fbb_.push_slot::( @@ -3625,16 +3636,16 @@ pub mod client_request { #[inline] pub fn add_contract_request( &mut self, - contract_request: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + contract_request: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( ContractRequest::VT_CONTRACT_REQUEST, contract_request, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ContractRequestBuilder<'a, 'b, A> { let start = _fbb.start_table(); ContractRequestBuilder { @@ -3643,16 +3654,16 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, ContractRequest::VT_CONTRACT_REQUEST, "contract_request"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ContractRequest<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ContractRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ContractRequest"); ds.field("contract_request_type", &self.contract_request_type()); match self.contract_request_type() { @@ -3708,25 +3719,25 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct DelegateRequest<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for DelegateRequest<'a> { + impl<'a> flatbuffers::Follow<'a> for DelegateRequest<'a> { type Inner = DelegateRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> DelegateRequest<'a> { - pub const VT_DELEGATE_REQUEST_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_DELEGATE_REQUEST: ::flatbuffers::VOffsetT = 6; + pub const VT_DELEGATE_REQUEST_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_DELEGATE_REQUEST: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { DelegateRequest { _tab: table } } #[allow(unused_mut)] @@ -3734,11 +3745,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args DelegateRequestArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = DelegateRequestBuilder::new(_fbb); if let Some(x) = args.delegate_request { builder.add_delegate_request(x); @@ -3762,13 +3773,13 @@ pub mod client_request { } } #[inline] - pub fn delegate_request(&self) -> ::flatbuffers::Table<'a> { + pub fn delegate_request(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( DelegateRequest::VT_DELEGATE_REQUEST, None, ) @@ -3818,18 +3829,19 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for DelegateRequest<'_> { + impl flatbuffers::Verifiable for DelegateRequest<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_union::("delegate_request_type", Self::VT_DELEGATE_REQUEST_TYPE, "delegate_request", Self::VT_DELEGATE_REQUEST, true, |key, v, pos| { match key { - DelegateRequestType::ApplicationMessages => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("DelegateRequestType::ApplicationMessages", pos), - DelegateRequestType::RegisterDelegate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("DelegateRequestType::RegisterDelegate", pos), - DelegateRequestType::UnregisterDelegate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("DelegateRequestType::UnregisterDelegate", pos), + DelegateRequestType::ApplicationMessages => v.verify_union_variant::>("DelegateRequestType::ApplicationMessages", pos), + DelegateRequestType::RegisterDelegate => v.verify_union_variant::>("DelegateRequestType::RegisterDelegate", pos), + DelegateRequestType::UnregisterDelegate => v.verify_union_variant::>("DelegateRequestType::UnregisterDelegate", pos), _ => Ok(()), } })? @@ -3839,7 +3851,7 @@ pub mod client_request { } pub struct DelegateRequestArgs { pub delegate_request_type: DelegateRequestType, - pub delegate_request: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub delegate_request: Option>, } impl<'a> Default for DelegateRequestArgs { #[inline] @@ -3851,11 +3863,11 @@ pub mod client_request { } } - pub struct DelegateRequestBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct DelegateRequestBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateRequestBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> DelegateRequestBuilder<'a, 'b, A> { #[inline] pub fn add_delegate_request_type(&mut self, delegate_request_type: DelegateRequestType) { self.fbb_.push_slot::( @@ -3867,16 +3879,16 @@ pub mod client_request { #[inline] pub fn add_delegate_request( &mut self, - delegate_request: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + delegate_request: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( DelegateRequest::VT_DELEGATE_REQUEST, delegate_request, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> DelegateRequestBuilder<'a, 'b, A> { let start = _fbb.start_table(); DelegateRequestBuilder { @@ -3885,16 +3897,16 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, DelegateRequest::VT_DELEGATE_REQUEST, "delegate_request"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for DelegateRequest<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for DelegateRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("DelegateRequest"); ds.field("delegate_request_type", &self.delegate_request_type()); match self.delegate_request_type() { @@ -3940,24 +3952,24 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct Disconnect<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for Disconnect<'a> { + impl<'a> flatbuffers::Follow<'a> for Disconnect<'a> { type Inner = Disconnect<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> Disconnect<'a> { - pub const VT_CAUSE: ::flatbuffers::VOffsetT = 4; + pub const VT_CAUSE: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Disconnect { _tab: table } } #[allow(unused_mut)] @@ -3965,11 +3977,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args DisconnectArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = DisconnectBuilder::new(_fbb); if let Some(x) = args.cause { builder.add_cause(x); @@ -3984,29 +3996,26 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<&str>>(Disconnect::VT_CAUSE, None) + .get::>(Disconnect::VT_CAUSE, None) } } } - impl ::flatbuffers::Verifiable for Disconnect<'_> { + impl flatbuffers::Verifiable for Disconnect<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<&str>>( - "cause", - Self::VT_CAUSE, - false, - )? + .visit_field::>("cause", Self::VT_CAUSE, false)? .finish(); Ok(()) } } pub struct DisconnectArgs<'a> { - pub cause: Option<::flatbuffers::WIPOffset<&'a str>>, + pub cause: Option>, } impl<'a> Default for DisconnectArgs<'a> { #[inline] @@ -4015,19 +4024,19 @@ pub mod client_request { } } - pub struct DisconnectBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct DisconnectBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DisconnectBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> DisconnectBuilder<'a, 'b, A> { #[inline] - pub fn add_cause(&mut self, cause: ::flatbuffers::WIPOffset<&'b str>) { + pub fn add_cause(&mut self, cause: flatbuffers::WIPOffset<&'b str>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(Disconnect::VT_CAUSE, cause); + .push_slot_always::>(Disconnect::VT_CAUSE, cause); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> DisconnectBuilder<'a, 'b, A> { let start = _fbb.start_table(); DisconnectBuilder { @@ -4036,14 +4045,14 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for Disconnect<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for Disconnect<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("Disconnect"); ds.field("cause", &self.cause()); ds.finish() @@ -4053,24 +4062,24 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct Authenticate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for Authenticate<'a> { + impl<'a> flatbuffers::Follow<'a> for Authenticate<'a> { type Inner = Authenticate<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> Authenticate<'a> { - pub const VT_TOKEN: ::flatbuffers::VOffsetT = 4; + pub const VT_TOKEN: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Authenticate { _tab: table } } #[allow(unused_mut)] @@ -4078,11 +4087,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args AuthenticateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = AuthenticateBuilder::new(_fbb); if let Some(x) = args.token { builder.add_token(x); @@ -4097,26 +4106,27 @@ pub mod client_request { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<&str>>(Authenticate::VT_TOKEN, None) + .get::>(Authenticate::VT_TOKEN, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for Authenticate<'_> { + impl flatbuffers::Verifiable for Authenticate<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("token", Self::VT_TOKEN, true)? + .visit_field::>("token", Self::VT_TOKEN, true)? .finish(); Ok(()) } } pub struct AuthenticateArgs<'a> { - pub token: Option<::flatbuffers::WIPOffset<&'a str>>, + pub token: Option>, } impl<'a> Default for AuthenticateArgs<'a> { #[inline] @@ -4127,19 +4137,19 @@ pub mod client_request { } } - pub struct AuthenticateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct AuthenticateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> AuthenticateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> AuthenticateBuilder<'a, 'b, A> { #[inline] - pub fn add_token(&mut self, token: ::flatbuffers::WIPOffset<&'b str>) { + pub fn add_token(&mut self, token: flatbuffers::WIPOffset<&'b str>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(Authenticate::VT_TOKEN, token); + .push_slot_always::>(Authenticate::VT_TOKEN, token); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> AuthenticateBuilder<'a, 'b, A> { let start = _fbb.start_table(); AuthenticateBuilder { @@ -4148,15 +4158,15 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, Authenticate::VT_TOKEN, "token"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for Authenticate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for Authenticate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("Authenticate"); ds.field("token", &self.token()); ds.finish() @@ -4166,25 +4176,25 @@ pub mod client_request { #[derive(Copy, Clone, PartialEq)] pub struct ClientRequest<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ClientRequest<'a> { + impl<'a> flatbuffers::Follow<'a> for ClientRequest<'a> { type Inner = ClientRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ClientRequest<'a> { - pub const VT_CLIENT_REQUEST_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_CLIENT_REQUEST: ::flatbuffers::VOffsetT = 6; + pub const VT_CLIENT_REQUEST_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_CLIENT_REQUEST: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ClientRequest { _tab: table } } #[allow(unused_mut)] @@ -4192,11 +4202,11 @@ pub mod client_request { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ClientRequestArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ClientRequestBuilder::new(_fbb); if let Some(x) = args.client_request { builder.add_client_request(x); @@ -4220,13 +4230,13 @@ pub mod client_request { } } #[inline] - pub fn client_request(&self) -> ::flatbuffers::Table<'a> { + pub fn client_request(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( ClientRequest::VT_CLIENT_REQUEST, None, ) @@ -4290,29 +4300,51 @@ pub mod client_request { } } - impl ::flatbuffers::Verifiable for ClientRequest<'_> { + impl flatbuffers::Verifiable for ClientRequest<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_union::("client_request_type", Self::VT_CLIENT_REQUEST_TYPE, "client_request", Self::VT_CLIENT_REQUEST, true, |key, v, pos| { - match key { - ClientRequestType::ContractRequest => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("ClientRequestType::ContractRequest", pos), - ClientRequestType::DelegateRequest => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("ClientRequestType::DelegateRequest", pos), - ClientRequestType::Disconnect => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("ClientRequestType::Disconnect", pos), - ClientRequestType::Authenticate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("ClientRequestType::Authenticate", pos), - _ => Ok(()), - } - })? - .finish(); + .visit_union::( + "client_request_type", + Self::VT_CLIENT_REQUEST_TYPE, + "client_request", + Self::VT_CLIENT_REQUEST, + true, + |key, v, pos| match key { + ClientRequestType::ContractRequest => v + .verify_union_variant::>( + "ClientRequestType::ContractRequest", + pos, + ), + ClientRequestType::DelegateRequest => v + .verify_union_variant::>( + "ClientRequestType::DelegateRequest", + pos, + ), + ClientRequestType::Disconnect => v + .verify_union_variant::>( + "ClientRequestType::Disconnect", + pos, + ), + ClientRequestType::Authenticate => v + .verify_union_variant::>( + "ClientRequestType::Authenticate", + pos, + ), + _ => Ok(()), + }, + )? + .finish(); Ok(()) } } pub struct ClientRequestArgs { pub client_request_type: ClientRequestType, - pub client_request: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub client_request: Option>, } impl<'a> Default for ClientRequestArgs { #[inline] @@ -4324,11 +4356,11 @@ pub mod client_request { } } - pub struct ClientRequestBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ClientRequestBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ClientRequestBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ClientRequestBuilder<'a, 'b, A> { #[inline] pub fn add_client_request_type(&mut self, client_request_type: ClientRequestType) { self.fbb_.push_slot::( @@ -4340,16 +4372,16 @@ pub mod client_request { #[inline] pub fn add_client_request( &mut self, - client_request: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + client_request: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( ClientRequest::VT_CLIENT_REQUEST, client_request, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ClientRequestBuilder<'a, 'b, A> { let start = _fbb.start_table(); ClientRequestBuilder { @@ -4358,16 +4390,16 @@ pub mod client_request { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, ClientRequest::VT_CLIENT_REQUEST, "client_request"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ClientRequest<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ClientRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ClientRequest"); ds.field("client_request_type", &self.client_request_type()); match self.client_request_type() { @@ -4428,8 +4460,8 @@ pub mod client_request { /// `root_as_client_request_unchecked`. pub fn root_as_client_request( buf: &[u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root::(buf) + ) -> Result { + flatbuffers::root::(buf) } #[inline] /// Verifies that a buffer of bytes contains a size prefixed @@ -4440,8 +4472,8 @@ pub mod client_request { /// `size_prefixed_root_as_client_request_unchecked`. pub fn size_prefixed_root_as_client_request( buf: &[u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root::(buf) + ) -> Result { + flatbuffers::size_prefixed_root::(buf) } #[inline] /// Verifies, with the given options, that a buffer of bytes @@ -4451,10 +4483,10 @@ pub mod client_request { /// previous, unchecked, behavior use /// `root_as_client_request_unchecked`. pub fn root_as_client_request_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, + opts: &'o flatbuffers::VerifierOptions, buf: &'b [u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root_with_opts::>(opts, buf) + ) -> Result, flatbuffers::InvalidFlatbuffer> { + flatbuffers::root_with_opts::>(opts, buf) } #[inline] /// Verifies, with the given verifier options, that a buffer of @@ -4464,37 +4496,37 @@ pub mod client_request { /// previous, unchecked, behavior use /// `root_as_client_request_unchecked`. pub fn size_prefixed_root_as_client_request_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, + opts: &'o flatbuffers::VerifierOptions, buf: &'b [u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) + ) -> Result, flatbuffers::InvalidFlatbuffer> { + flatbuffers::size_prefixed_root_with_opts::>(opts, buf) } #[inline] /// Assumes, without verification, that a buffer of bytes contains a ClientRequest and returns it. /// # Safety /// Callers must trust the given bytes do indeed contain a valid `ClientRequest`. - pub unsafe fn root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest<'_> { - unsafe { ::flatbuffers::root_unchecked::(buf) } + pub unsafe fn root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest { + flatbuffers::root_unchecked::(buf) } #[inline] /// Assumes, without verification, that a buffer of bytes contains a size prefixed ClientRequest and returns it. /// # Safety /// Callers must trust the given bytes do indeed contain a valid size prefixed `ClientRequest`. - pub unsafe fn size_prefixed_root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest<'_> { - unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } + pub unsafe fn size_prefixed_root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest { + flatbuffers::size_prefixed_root_unchecked::(buf) } #[inline] - pub fn finish_client_request_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( - fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>, + pub fn finish_client_request_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>( + fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + root: flatbuffers::WIPOffset>, ) { fbb.finish(root, None); } #[inline] - pub fn finish_size_prefixed_client_request_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( - fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>, + pub fn finish_size_prefixed_client_request_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>( + fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + root: flatbuffers::WIPOffset>, ) { fbb.finish_size_prefixed(root, None); } diff --git a/rust/src/generated/common_generated.rs b/rust/src/generated/common_generated.rs index b19b97f..133b1c4 100644 --- a/rust/src/generated/common_generated.rs +++ b/rust/src/generated/common_generated.rs @@ -1,10 +1,22 @@ // automatically generated by the FlatBuffers compiler, do not modify + // @generated -extern crate alloc; + +use core::cmp::Ordering; +use core::mem; + +extern crate flatbuffers; +use self::flatbuffers::{EndianScalar, Follow}; #[allow(unused_imports, dead_code)] pub mod common { + use core::cmp::Ordering; + use core::mem; + + extern crate flatbuffers; + use self::flatbuffers::{EndianScalar, Follow}; + #[deprecated( since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021." @@ -43,8 +55,8 @@ pub mod common { } } } - impl ::core::fmt::Debug for ContractType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for ContractType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -52,24 +64,24 @@ pub mod common { } } } - impl<'a> ::flatbuffers::Follow<'a> for ContractType { + impl<'a> flatbuffers::Follow<'a> for ContractType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for ContractType { + impl flatbuffers::Push for ContractType { type Output = ContractType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for ContractType { + impl flatbuffers::EndianScalar for ContractType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -83,17 +95,18 @@ pub mod common { } } - impl<'a> ::flatbuffers::Verifiable for ContractType { + impl<'a> flatbuffers::Verifiable for ContractType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for ContractType {} + impl flatbuffers::SimpleToVerifyInSlice for ContractType {} pub struct ContractTypeUnionTableOffset {} #[deprecated( @@ -159,8 +172,8 @@ pub mod common { } } } - impl ::core::fmt::Debug for UpdateDataType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for UpdateDataType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -168,24 +181,24 @@ pub mod common { } } } - impl<'a> ::flatbuffers::Follow<'a> for UpdateDataType { + impl<'a> flatbuffers::Follow<'a> for UpdateDataType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for UpdateDataType { + impl flatbuffers::Push for UpdateDataType { type Output = UpdateDataType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for UpdateDataType { + impl flatbuffers::EndianScalar for UpdateDataType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -199,41 +212,42 @@ pub mod common { } } - impl<'a> ::flatbuffers::Verifiable for UpdateDataType { + impl<'a> flatbuffers::Verifiable for UpdateDataType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for UpdateDataType {} + impl flatbuffers::SimpleToVerifyInSlice for UpdateDataType {} pub struct UpdateDataTypeUnionTableOffset {} pub enum ContractInstanceIdOffset {} #[derive(Copy, Clone, PartialEq)] pub struct ContractInstanceId<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ContractInstanceId<'a> { + impl<'a> flatbuffers::Follow<'a> for ContractInstanceId<'a> { type Inner = ContractInstanceId<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ContractInstanceId<'a> { - pub const VT_DATA: ::flatbuffers::VOffsetT = 4; + pub const VT_DATA: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ContractInstanceId { _tab: table } } #[allow(unused_mut)] @@ -241,11 +255,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ContractInstanceIdArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ContractInstanceIdBuilder::new(_fbb); if let Some(x) = args.data { builder.add_data(x); @@ -254,13 +268,13 @@ pub mod common { } #[inline] - pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn data(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ContractInstanceId::VT_DATA, None, ) @@ -269,14 +283,15 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for ContractInstanceId<'_> { + impl flatbuffers::Verifiable for ContractInstanceId<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "data", Self::VT_DATA, true, @@ -286,7 +301,7 @@ pub mod common { } } pub struct ContractInstanceIdArgs<'a> { - pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub data: Option>>, } impl<'a> Default for ContractInstanceIdArgs<'a> { #[inline] @@ -297,19 +312,19 @@ pub mod common { } } - pub struct ContractInstanceIdBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ContractInstanceIdBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractInstanceIdBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ContractInstanceIdBuilder<'a, 'b, A> { #[inline] - pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(ContractInstanceId::VT_DATA, data); + .push_slot_always::>(ContractInstanceId::VT_DATA, data); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ContractInstanceIdBuilder<'a, 'b, A> { let start = _fbb.start_table(); ContractInstanceIdBuilder { @@ -318,15 +333,15 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, ContractInstanceId::VT_DATA, "data"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ContractInstanceId<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ContractInstanceId<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ContractInstanceId"); ds.field("data", &self.data()); ds.finish() @@ -336,25 +351,25 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct ContractKey<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ContractKey<'a> { + impl<'a> flatbuffers::Follow<'a> for ContractKey<'a> { type Inner = ContractKey<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ContractKey<'a> { - pub const VT_INSTANCE: ::flatbuffers::VOffsetT = 4; - pub const VT_CODE: ::flatbuffers::VOffsetT = 6; + pub const VT_INSTANCE: flatbuffers::VOffsetT = 4; + pub const VT_CODE: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ContractKey { _tab: table } } #[allow(unused_mut)] @@ -362,11 +377,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ContractKeyArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ContractKeyBuilder::new(_fbb); if let Some(x) = args.code { builder.add_code(x); @@ -384,7 +399,7 @@ pub mod common { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( ContractKey::VT_INSTANCE, None, ) @@ -392,13 +407,13 @@ pub mod common { } } #[inline] - pub fn code(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + pub fn code(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ContractKey::VT_CODE, None, ) @@ -406,19 +421,20 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for ContractKey<'_> { + impl flatbuffers::Verifiable for ContractKey<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "instance", Self::VT_INSTANCE, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "code", Self::VT_CODE, false, @@ -428,8 +444,8 @@ pub mod common { } } pub struct ContractKeyArgs<'a> { - pub instance: Option<::flatbuffers::WIPOffset>>, - pub code: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub instance: Option>>, + pub code: Option>>, } impl<'a> Default for ContractKeyArgs<'a> { #[inline] @@ -441,27 +457,27 @@ pub mod common { } } - pub struct ContractKeyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ContractKeyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractKeyBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ContractKeyBuilder<'a, 'b, A> { #[inline] - pub fn add_instance(&mut self, instance: ::flatbuffers::WIPOffset>) { + pub fn add_instance(&mut self, instance: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( ContractKey::VT_INSTANCE, instance, ); } #[inline] - pub fn add_code(&mut self, code: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_code(&mut self, code: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(ContractKey::VT_CODE, code); + .push_slot_always::>(ContractKey::VT_CODE, code); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ContractKeyBuilder<'a, 'b, A> { let start = _fbb.start_table(); ContractKeyBuilder { @@ -470,15 +486,15 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, ContractKey::VT_INSTANCE, "instance"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ContractKey<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ContractKey<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ContractKey"); ds.field("instance", &self.instance()); ds.field("code", &self.code()); @@ -489,25 +505,25 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct SecretsId<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for SecretsId<'a> { + impl<'a> flatbuffers::Follow<'a> for SecretsId<'a> { type Inner = SecretsId<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> SecretsId<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_HASH: ::flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_HASH: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { SecretsId { _tab: table } } #[allow(unused_mut)] @@ -515,11 +531,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args SecretsIdArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = SecretsIdBuilder::new(_fbb); if let Some(x) = args.hash { builder.add_hash(x); @@ -531,13 +547,13 @@ pub mod common { } #[inline] - pub fn key(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn key(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( SecretsId::VT_KEY, None, ) @@ -545,13 +561,13 @@ pub mod common { } } #[inline] - pub fn hash(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn hash(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( SecretsId::VT_HASH, None, ) @@ -560,19 +576,20 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for SecretsId<'_> { + impl flatbuffers::Verifiable for SecretsId<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "hash", Self::VT_HASH, true, @@ -582,8 +599,8 @@ pub mod common { } } pub struct SecretsIdArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub key: Option>>, + pub hash: Option>>, } impl<'a> Default for SecretsIdArgs<'a> { #[inline] @@ -595,24 +612,24 @@ pub mod common { } } - pub struct SecretsIdBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct SecretsIdBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SecretsIdBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> SecretsIdBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(SecretsId::VT_KEY, key); + .push_slot_always::>(SecretsId::VT_KEY, key); } #[inline] - pub fn add_hash(&mut self, hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_hash(&mut self, hash: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(SecretsId::VT_HASH, hash); + .push_slot_always::>(SecretsId::VT_HASH, hash); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> SecretsIdBuilder<'a, 'b, A> { let start = _fbb.start_table(); SecretsIdBuilder { @@ -621,16 +638,16 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, SecretsId::VT_KEY, "key"); self.fbb_.required(o, SecretsId::VT_HASH, "hash"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for SecretsId<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for SecretsId<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("SecretsId"); ds.field("key", &self.key()); ds.field("hash", &self.hash()); @@ -641,25 +658,25 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct ContractCode<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ContractCode<'a> { + impl<'a> flatbuffers::Follow<'a> for ContractCode<'a> { type Inner = ContractCode<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ContractCode<'a> { - pub const VT_DATA: ::flatbuffers::VOffsetT = 4; - pub const VT_CODE_HASH: ::flatbuffers::VOffsetT = 6; + pub const VT_DATA: flatbuffers::VOffsetT = 4; + pub const VT_CODE_HASH: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ContractCode { _tab: table } } #[allow(unused_mut)] @@ -667,11 +684,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ContractCodeArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ContractCodeBuilder::new(_fbb); if let Some(x) = args.code_hash { builder.add_code_hash(x); @@ -683,13 +700,13 @@ pub mod common { } #[inline] - pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn data(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ContractCode::VT_DATA, None, ) @@ -697,13 +714,13 @@ pub mod common { } } #[inline] - pub fn code_hash(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn code_hash(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ContractCode::VT_CODE_HASH, None, ) @@ -712,19 +729,20 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for ContractCode<'_> { + impl flatbuffers::Verifiable for ContractCode<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "data", Self::VT_DATA, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "code_hash", Self::VT_CODE_HASH, true, @@ -734,8 +752,8 @@ pub mod common { } } pub struct ContractCodeArgs<'a> { - pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub code_hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub data: Option>>, + pub code_hash: Option>>, } impl<'a> Default for ContractCodeArgs<'a> { #[inline] @@ -747,29 +765,29 @@ pub mod common { } } - pub struct ContractCodeBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ContractCodeBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractCodeBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ContractCodeBuilder<'a, 'b, A> { #[inline] - pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(ContractCode::VT_DATA, data); + .push_slot_always::>(ContractCode::VT_DATA, data); } #[inline] pub fn add_code_hash( &mut self, - code_hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + code_hash: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( ContractCode::VT_CODE_HASH, code_hash, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ContractCodeBuilder<'a, 'b, A> { let start = _fbb.start_table(); ContractCodeBuilder { @@ -778,17 +796,17 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, ContractCode::VT_DATA, "data"); self.fbb_ .required(o, ContractCode::VT_CODE_HASH, "code_hash"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ContractCode<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ContractCode<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ContractCode"); ds.field("data", &self.data()); ds.field("code_hash", &self.code_hash()); @@ -799,27 +817,27 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct ApplicationMessage<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ApplicationMessage<'a> { + impl<'a> flatbuffers::Follow<'a> for ApplicationMessage<'a> { type Inner = ApplicationMessage<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ApplicationMessage<'a> { - pub const VT_APP: ::flatbuffers::VOffsetT = 4; - pub const VT_PAYLOAD: ::flatbuffers::VOffsetT = 6; - pub const VT_CONTEXT: ::flatbuffers::VOffsetT = 8; - pub const VT_PROCESSED: ::flatbuffers::VOffsetT = 10; + pub const VT_APP: flatbuffers::VOffsetT = 4; + pub const VT_PAYLOAD: flatbuffers::VOffsetT = 6; + pub const VT_CONTEXT: flatbuffers::VOffsetT = 8; + pub const VT_PROCESSED: flatbuffers::VOffsetT = 10; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ApplicationMessage { _tab: table } } #[allow(unused_mut)] @@ -827,11 +845,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ApplicationMessageArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ApplicationMessageBuilder::new(_fbb); if let Some(x) = args.context { builder.add_context(x); @@ -853,7 +871,7 @@ pub mod common { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( ApplicationMessage::VT_APP, None, ) @@ -861,13 +879,13 @@ pub mod common { } } #[inline] - pub fn payload(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn payload(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ApplicationMessage::VT_PAYLOAD, None, ) @@ -875,13 +893,13 @@ pub mod common { } } #[inline] - pub fn context(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn context(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ApplicationMessage::VT_CONTEXT, None, ) @@ -901,24 +919,25 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for ApplicationMessage<'_> { + impl flatbuffers::Verifiable for ApplicationMessage<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "app", Self::VT_APP, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "payload", Self::VT_PAYLOAD, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "context", Self::VT_CONTEXT, true, @@ -929,9 +948,9 @@ pub mod common { } } pub struct ApplicationMessageArgs<'a> { - pub app: Option<::flatbuffers::WIPOffset>>, - pub payload: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub context: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub app: Option>>, + pub payload: Option>>, + pub context: Option>>, pub processed: bool, } impl<'a> Default for ApplicationMessageArgs<'a> { @@ -946,15 +965,15 @@ pub mod common { } } - pub struct ApplicationMessageBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ApplicationMessageBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ApplicationMessageBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ApplicationMessageBuilder<'a, 'b, A> { #[inline] - pub fn add_app(&mut self, app: ::flatbuffers::WIPOffset>) { + pub fn add_app(&mut self, app: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( ApplicationMessage::VT_APP, app, ); @@ -962,9 +981,9 @@ pub mod common { #[inline] pub fn add_payload( &mut self, - payload: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + payload: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( ApplicationMessage::VT_PAYLOAD, payload, ); @@ -972,9 +991,9 @@ pub mod common { #[inline] pub fn add_context( &mut self, - context: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + context: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( ApplicationMessage::VT_CONTEXT, context, ); @@ -986,7 +1005,7 @@ pub mod common { } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ApplicationMessageBuilder<'a, 'b, A> { let start = _fbb.start_table(); ApplicationMessageBuilder { @@ -995,19 +1014,19 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, ApplicationMessage::VT_APP, "app"); self.fbb_ .required(o, ApplicationMessage::VT_PAYLOAD, "payload"); self.fbb_ .required(o, ApplicationMessage::VT_CONTEXT, "context"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ApplicationMessage<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ApplicationMessage<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ApplicationMessage"); ds.field("app", &self.app()); ds.field("payload", &self.payload()); @@ -1020,26 +1039,26 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct WasmContractV1<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for WasmContractV1<'a> { + impl<'a> flatbuffers::Follow<'a> for WasmContractV1<'a> { type Inner = WasmContractV1<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> WasmContractV1<'a> { - pub const VT_DATA: ::flatbuffers::VOffsetT = 4; - pub const VT_PARAMETERS: ::flatbuffers::VOffsetT = 6; - pub const VT_KEY: ::flatbuffers::VOffsetT = 8; + pub const VT_DATA: flatbuffers::VOffsetT = 4; + pub const VT_PARAMETERS: flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { WasmContractV1 { _tab: table } } #[allow(unused_mut)] @@ -1047,11 +1066,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args WasmContractV1Args<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = WasmContractV1Builder::new(_fbb); if let Some(x) = args.key { builder.add_key(x); @@ -1072,7 +1091,7 @@ pub mod common { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( WasmContractV1::VT_DATA, None, ) @@ -1080,13 +1099,13 @@ pub mod common { } } #[inline] - pub fn parameters(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn parameters(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( WasmContractV1::VT_PARAMETERS, None, ) @@ -1100,33 +1119,31 @@ pub mod common { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( - WasmContractV1::VT_KEY, - None, - ) + .get::>(WasmContractV1::VT_KEY, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for WasmContractV1<'_> { + impl flatbuffers::Verifiable for WasmContractV1<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "data", Self::VT_DATA, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "parameters", Self::VT_PARAMETERS, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, @@ -1136,9 +1153,9 @@ pub mod common { } } pub struct WasmContractV1Args<'a> { - pub data: Option<::flatbuffers::WIPOffset>>, - pub parameters: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub key: Option<::flatbuffers::WIPOffset>>, + pub data: Option>>, + pub parameters: Option>>, + pub key: Option>>, } impl<'a> Default for WasmContractV1Args<'a> { #[inline] @@ -1151,15 +1168,15 @@ pub mod common { } } - pub struct WasmContractV1Builder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct WasmContractV1Builder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WasmContractV1Builder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> WasmContractV1Builder<'a, 'b, A> { #[inline] - pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset>) { + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( WasmContractV1::VT_DATA, data, ); @@ -1167,24 +1184,24 @@ pub mod common { #[inline] pub fn add_parameters( &mut self, - parameters: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + parameters: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( WasmContractV1::VT_PARAMETERS, parameters, ); } #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( WasmContractV1::VT_KEY, key, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> WasmContractV1Builder<'a, 'b, A> { let start = _fbb.start_table(); WasmContractV1Builder { @@ -1193,18 +1210,18 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, WasmContractV1::VT_DATA, "data"); self.fbb_ .required(o, WasmContractV1::VT_PARAMETERS, "parameters"); self.fbb_.required(o, WasmContractV1::VT_KEY, "key"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for WasmContractV1<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for WasmContractV1<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("WasmContractV1"); ds.field("data", &self.data()); ds.field("parameters", &self.parameters()); @@ -1216,25 +1233,25 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct ContractContainer<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ContractContainer<'a> { + impl<'a> flatbuffers::Follow<'a> for ContractContainer<'a> { type Inner = ContractContainer<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ContractContainer<'a> { - pub const VT_CONTRACT_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_CONTRACT: ::flatbuffers::VOffsetT = 6; + pub const VT_CONTRACT_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_CONTRACT: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ContractContainer { _tab: table } } #[allow(unused_mut)] @@ -1242,11 +1259,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ContractContainerArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ContractContainerBuilder::new(_fbb); if let Some(x) = args.contract { builder.add_contract(x); @@ -1270,13 +1287,13 @@ pub mod common { } } #[inline] - pub fn contract(&self) -> ::flatbuffers::Table<'a> { + pub fn contract(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( ContractContainer::VT_CONTRACT, None, ) @@ -1298,12 +1315,13 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for ContractContainer<'_> { + impl flatbuffers::Verifiable for ContractContainer<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_union::( "contract_type", @@ -1313,7 +1331,7 @@ pub mod common { true, |key, v, pos| match key { ContractType::WasmContractV1 => v - .verify_union_variant::<::flatbuffers::ForwardsUOffset>( + .verify_union_variant::>( "ContractType::WasmContractV1", pos, ), @@ -1326,7 +1344,7 @@ pub mod common { } pub struct ContractContainerArgs { pub contract_type: ContractType, - pub contract: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub contract: Option>, } impl<'a> Default for ContractContainerArgs { #[inline] @@ -1338,11 +1356,11 @@ pub mod common { } } - pub struct ContractContainerBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ContractContainerBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractContainerBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ContractContainerBuilder<'a, 'b, A> { #[inline] pub fn add_contract_type(&mut self, contract_type: ContractType) { self.fbb_.push_slot::( @@ -1354,16 +1372,16 @@ pub mod common { #[inline] pub fn add_contract( &mut self, - contract: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + contract: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( ContractContainer::VT_CONTRACT, contract, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ContractContainerBuilder<'a, 'b, A> { let start = _fbb.start_table(); ContractContainerBuilder { @@ -1372,16 +1390,16 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, ContractContainer::VT_CONTRACT, "contract"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ContractContainer<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ContractContainer<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ContractContainer"); ds.field("contract_type", &self.contract_type()); match self.contract_type() { @@ -1407,24 +1425,24 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct StateUpdate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for StateUpdate<'a> { + impl<'a> flatbuffers::Follow<'a> for StateUpdate<'a> { type Inner = StateUpdate<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> StateUpdate<'a> { - pub const VT_STATE: ::flatbuffers::VOffsetT = 4; + pub const VT_STATE: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { StateUpdate { _tab: table } } #[allow(unused_mut)] @@ -1432,11 +1450,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args StateUpdateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = StateUpdateBuilder::new(_fbb); if let Some(x) = args.state { builder.add_state(x); @@ -1445,13 +1463,13 @@ pub mod common { } #[inline] - pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn state(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( StateUpdate::VT_STATE, None, ) @@ -1460,14 +1478,15 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for StateUpdate<'_> { + impl flatbuffers::Verifiable for StateUpdate<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "state", Self::VT_STATE, true, @@ -1477,7 +1496,7 @@ pub mod common { } } pub struct StateUpdateArgs<'a> { - pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub state: Option>>, } impl<'a> Default for StateUpdateArgs<'a> { #[inline] @@ -1488,22 +1507,19 @@ pub mod common { } } - pub struct StateUpdateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct StateUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StateUpdateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> StateUpdateBuilder<'a, 'b, A> { #[inline] - pub fn add_state( - &mut self, - state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { + pub fn add_state(&mut self, state: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(StateUpdate::VT_STATE, state); + .push_slot_always::>(StateUpdate::VT_STATE, state); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> StateUpdateBuilder<'a, 'b, A> { let start = _fbb.start_table(); StateUpdateBuilder { @@ -1512,15 +1528,15 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, StateUpdate::VT_STATE, "state"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for StateUpdate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for StateUpdate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("StateUpdate"); ds.field("state", &self.state()); ds.finish() @@ -1530,24 +1546,24 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct DeltaUpdate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for DeltaUpdate<'a> { + impl<'a> flatbuffers::Follow<'a> for DeltaUpdate<'a> { type Inner = DeltaUpdate<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> DeltaUpdate<'a> { - pub const VT_DELTA: ::flatbuffers::VOffsetT = 4; + pub const VT_DELTA: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { DeltaUpdate { _tab: table } } #[allow(unused_mut)] @@ -1555,11 +1571,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args DeltaUpdateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = DeltaUpdateBuilder::new(_fbb); if let Some(x) = args.delta { builder.add_delta(x); @@ -1568,13 +1584,13 @@ pub mod common { } #[inline] - pub fn delta(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn delta(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( DeltaUpdate::VT_DELTA, None, ) @@ -1583,14 +1599,15 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for DeltaUpdate<'_> { + impl flatbuffers::Verifiable for DeltaUpdate<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "delta", Self::VT_DELTA, true, @@ -1600,7 +1617,7 @@ pub mod common { } } pub struct DeltaUpdateArgs<'a> { - pub delta: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub delta: Option>>, } impl<'a> Default for DeltaUpdateArgs<'a> { #[inline] @@ -1611,22 +1628,19 @@ pub mod common { } } - pub struct DeltaUpdateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct DeltaUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DeltaUpdateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> DeltaUpdateBuilder<'a, 'b, A> { #[inline] - pub fn add_delta( - &mut self, - delta: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { + pub fn add_delta(&mut self, delta: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(DeltaUpdate::VT_DELTA, delta); + .push_slot_always::>(DeltaUpdate::VT_DELTA, delta); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> DeltaUpdateBuilder<'a, 'b, A> { let start = _fbb.start_table(); DeltaUpdateBuilder { @@ -1635,15 +1649,15 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, DeltaUpdate::VT_DELTA, "delta"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for DeltaUpdate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for DeltaUpdate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("DeltaUpdate"); ds.field("delta", &self.delta()); ds.finish() @@ -1653,25 +1667,25 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct StateAndDeltaUpdate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for StateAndDeltaUpdate<'a> { + impl<'a> flatbuffers::Follow<'a> for StateAndDeltaUpdate<'a> { type Inner = StateAndDeltaUpdate<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> StateAndDeltaUpdate<'a> { - pub const VT_STATE: ::flatbuffers::VOffsetT = 4; - pub const VT_DELTA: ::flatbuffers::VOffsetT = 6; + pub const VT_STATE: flatbuffers::VOffsetT = 4; + pub const VT_DELTA: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { StateAndDeltaUpdate { _tab: table } } #[allow(unused_mut)] @@ -1679,11 +1693,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args StateAndDeltaUpdateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = StateAndDeltaUpdateBuilder::new(_fbb); if let Some(x) = args.delta { builder.add_delta(x); @@ -1695,13 +1709,13 @@ pub mod common { } #[inline] - pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn state(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( StateAndDeltaUpdate::VT_STATE, None, ) @@ -1709,13 +1723,13 @@ pub mod common { } } #[inline] - pub fn delta(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn delta(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( StateAndDeltaUpdate::VT_DELTA, None, ) @@ -1724,19 +1738,20 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for StateAndDeltaUpdate<'_> { + impl flatbuffers::Verifiable for StateAndDeltaUpdate<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "state", Self::VT_STATE, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "delta", Self::VT_DELTA, true, @@ -1746,8 +1761,8 @@ pub mod common { } } pub struct StateAndDeltaUpdateArgs<'a> { - pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub delta: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub state: Option>>, + pub delta: Option>>, } impl<'a> Default for StateAndDeltaUpdateArgs<'a> { #[inline] @@ -1759,34 +1774,28 @@ pub mod common { } } - pub struct StateAndDeltaUpdateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct StateAndDeltaUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StateAndDeltaUpdateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> StateAndDeltaUpdateBuilder<'a, 'b, A> { #[inline] - pub fn add_state( - &mut self, - state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + pub fn add_state(&mut self, state: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>( StateAndDeltaUpdate::VT_STATE, state, ); } #[inline] - pub fn add_delta( - &mut self, - delta: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + pub fn add_delta(&mut self, delta: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>( StateAndDeltaUpdate::VT_DELTA, delta, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> StateAndDeltaUpdateBuilder<'a, 'b, A> { let start = _fbb.start_table(); StateAndDeltaUpdateBuilder { @@ -1795,18 +1804,18 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, StateAndDeltaUpdate::VT_STATE, "state"); self.fbb_ .required(o, StateAndDeltaUpdate::VT_DELTA, "delta"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for StateAndDeltaUpdate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for StateAndDeltaUpdate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("StateAndDeltaUpdate"); ds.field("state", &self.state()); ds.field("delta", &self.delta()); @@ -1817,25 +1826,25 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct RelatedStateUpdate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for RelatedStateUpdate<'a> { + impl<'a> flatbuffers::Follow<'a> for RelatedStateUpdate<'a> { type Inner = RelatedStateUpdate<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> RelatedStateUpdate<'a> { - pub const VT_RELATED_TO: ::flatbuffers::VOffsetT = 4; - pub const VT_STATE: ::flatbuffers::VOffsetT = 6; + pub const VT_RELATED_TO: flatbuffers::VOffsetT = 4; + pub const VT_STATE: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { RelatedStateUpdate { _tab: table } } #[allow(unused_mut)] @@ -1843,11 +1852,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args RelatedStateUpdateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = RelatedStateUpdateBuilder::new(_fbb); if let Some(x) = args.state { builder.add_state(x); @@ -1865,7 +1874,7 @@ pub mod common { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( RelatedStateUpdate::VT_RELATED_TO, None, ) @@ -1873,13 +1882,13 @@ pub mod common { } } #[inline] - pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn state(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( RelatedStateUpdate::VT_STATE, None, ) @@ -1888,19 +1897,20 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for RelatedStateUpdate<'_> { + impl flatbuffers::Verifiable for RelatedStateUpdate<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "related_to", Self::VT_RELATED_TO, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "state", Self::VT_STATE, true, @@ -1910,8 +1920,8 @@ pub mod common { } } pub struct RelatedStateUpdateArgs<'a> { - pub related_to: Option<::flatbuffers::WIPOffset>>, - pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub related_to: Option>>, + pub state: Option>>, } impl<'a> Default for RelatedStateUpdateArgs<'a> { #[inline] @@ -1923,35 +1933,30 @@ pub mod common { } } - pub struct RelatedStateUpdateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct RelatedStateUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedStateUpdateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> RelatedStateUpdateBuilder<'a, 'b, A> { #[inline] pub fn add_related_to( &mut self, - related_to: ::flatbuffers::WIPOffset>, + related_to: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( RelatedStateUpdate::VT_RELATED_TO, related_to, ); } #[inline] - pub fn add_state( - &mut self, - state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( - RelatedStateUpdate::VT_STATE, - state, - ); + pub fn add_state(&mut self, state: flatbuffers::WIPOffset>) { + self.fbb_ + .push_slot_always::>(RelatedStateUpdate::VT_STATE, state); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> RelatedStateUpdateBuilder<'a, 'b, A> { let start = _fbb.start_table(); RelatedStateUpdateBuilder { @@ -1960,17 +1965,17 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, RelatedStateUpdate::VT_RELATED_TO, "related_to"); self.fbb_.required(o, RelatedStateUpdate::VT_STATE, "state"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for RelatedStateUpdate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for RelatedStateUpdate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("RelatedStateUpdate"); ds.field("related_to", &self.related_to()); ds.field("state", &self.state()); @@ -1981,25 +1986,25 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct RelatedDeltaUpdate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for RelatedDeltaUpdate<'a> { + impl<'a> flatbuffers::Follow<'a> for RelatedDeltaUpdate<'a> { type Inner = RelatedDeltaUpdate<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> RelatedDeltaUpdate<'a> { - pub const VT_RELATED_TO: ::flatbuffers::VOffsetT = 4; - pub const VT_DELTA: ::flatbuffers::VOffsetT = 6; + pub const VT_RELATED_TO: flatbuffers::VOffsetT = 4; + pub const VT_DELTA: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { RelatedDeltaUpdate { _tab: table } } #[allow(unused_mut)] @@ -2007,11 +2012,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args RelatedDeltaUpdateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = RelatedDeltaUpdateBuilder::new(_fbb); if let Some(x) = args.delta { builder.add_delta(x); @@ -2029,7 +2034,7 @@ pub mod common { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( RelatedDeltaUpdate::VT_RELATED_TO, None, ) @@ -2037,13 +2042,13 @@ pub mod common { } } #[inline] - pub fn delta(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn delta(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( RelatedDeltaUpdate::VT_DELTA, None, ) @@ -2052,19 +2057,20 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for RelatedDeltaUpdate<'_> { + impl flatbuffers::Verifiable for RelatedDeltaUpdate<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "related_to", Self::VT_RELATED_TO, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "delta", Self::VT_DELTA, true, @@ -2074,8 +2080,8 @@ pub mod common { } } pub struct RelatedDeltaUpdateArgs<'a> { - pub related_to: Option<::flatbuffers::WIPOffset>>, - pub delta: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub related_to: Option>>, + pub delta: Option>>, } impl<'a> Default for RelatedDeltaUpdateArgs<'a> { #[inline] @@ -2087,35 +2093,30 @@ pub mod common { } } - pub struct RelatedDeltaUpdateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct RelatedDeltaUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedDeltaUpdateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> RelatedDeltaUpdateBuilder<'a, 'b, A> { #[inline] pub fn add_related_to( &mut self, - related_to: ::flatbuffers::WIPOffset>, + related_to: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( RelatedDeltaUpdate::VT_RELATED_TO, related_to, ); } #[inline] - pub fn add_delta( - &mut self, - delta: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( - RelatedDeltaUpdate::VT_DELTA, - delta, - ); + pub fn add_delta(&mut self, delta: flatbuffers::WIPOffset>) { + self.fbb_ + .push_slot_always::>(RelatedDeltaUpdate::VT_DELTA, delta); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> RelatedDeltaUpdateBuilder<'a, 'b, A> { let start = _fbb.start_table(); RelatedDeltaUpdateBuilder { @@ -2124,17 +2125,17 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, RelatedDeltaUpdate::VT_RELATED_TO, "related_to"); self.fbb_.required(o, RelatedDeltaUpdate::VT_DELTA, "delta"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for RelatedDeltaUpdate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for RelatedDeltaUpdate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("RelatedDeltaUpdate"); ds.field("related_to", &self.related_to()); ds.field("delta", &self.delta()); @@ -2145,26 +2146,26 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct RelatedStateAndDeltaUpdate<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for RelatedStateAndDeltaUpdate<'a> { + impl<'a> flatbuffers::Follow<'a> for RelatedStateAndDeltaUpdate<'a> { type Inner = RelatedStateAndDeltaUpdate<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> RelatedStateAndDeltaUpdate<'a> { - pub const VT_RELATED_TO: ::flatbuffers::VOffsetT = 4; - pub const VT_STATE: ::flatbuffers::VOffsetT = 6; - pub const VT_DELTA: ::flatbuffers::VOffsetT = 8; + pub const VT_RELATED_TO: flatbuffers::VOffsetT = 4; + pub const VT_STATE: flatbuffers::VOffsetT = 6; + pub const VT_DELTA: flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { RelatedStateAndDeltaUpdate { _tab: table } } #[allow(unused_mut)] @@ -2172,11 +2173,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args RelatedStateAndDeltaUpdateArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = RelatedStateAndDeltaUpdateBuilder::new(_fbb); if let Some(x) = args.delta { builder.add_delta(x); @@ -2197,7 +2198,7 @@ pub mod common { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( RelatedStateAndDeltaUpdate::VT_RELATED_TO, None, ) @@ -2205,13 +2206,13 @@ pub mod common { } } #[inline] - pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn state(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( RelatedStateAndDeltaUpdate::VT_STATE, None, ) @@ -2219,13 +2220,13 @@ pub mod common { } } #[inline] - pub fn delta(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn delta(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( RelatedStateAndDeltaUpdate::VT_DELTA, None, ) @@ -2234,24 +2235,25 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for RelatedStateAndDeltaUpdate<'_> { + impl flatbuffers::Verifiable for RelatedStateAndDeltaUpdate<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "related_to", Self::VT_RELATED_TO, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "state", Self::VT_STATE, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "delta", Self::VT_DELTA, true, @@ -2261,9 +2263,9 @@ pub mod common { } } pub struct RelatedStateAndDeltaUpdateArgs<'a> { - pub related_to: Option<::flatbuffers::WIPOffset>>, - pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub delta: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub related_to: Option>>, + pub state: Option>>, + pub delta: Option>>, } impl<'a> Default for RelatedStateAndDeltaUpdateArgs<'a> { #[inline] @@ -2276,45 +2278,39 @@ pub mod common { } } - pub struct RelatedStateAndDeltaUpdateBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct RelatedStateAndDeltaUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedStateAndDeltaUpdateBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> RelatedStateAndDeltaUpdateBuilder<'a, 'b, A> { #[inline] pub fn add_related_to( &mut self, - related_to: ::flatbuffers::WIPOffset>, + related_to: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( RelatedStateAndDeltaUpdate::VT_RELATED_TO, related_to, ); } #[inline] - pub fn add_state( - &mut self, - state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + pub fn add_state(&mut self, state: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>( RelatedStateAndDeltaUpdate::VT_STATE, state, ); } #[inline] - pub fn add_delta( - &mut self, - delta: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + pub fn add_delta(&mut self, delta: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>( RelatedStateAndDeltaUpdate::VT_DELTA, delta, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> RelatedStateAndDeltaUpdateBuilder<'a, 'b, A> { let start = _fbb.start_table(); RelatedStateAndDeltaUpdateBuilder { @@ -2323,7 +2319,7 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, RelatedStateAndDeltaUpdate::VT_RELATED_TO, "related_to"); @@ -2331,12 +2327,12 @@ pub mod common { .required(o, RelatedStateAndDeltaUpdate::VT_STATE, "state"); self.fbb_ .required(o, RelatedStateAndDeltaUpdate::VT_DELTA, "delta"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for RelatedStateAndDeltaUpdate<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for RelatedStateAndDeltaUpdate<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("RelatedStateAndDeltaUpdate"); ds.field("related_to", &self.related_to()); ds.field("state", &self.state()); @@ -2348,25 +2344,25 @@ pub mod common { #[derive(Copy, Clone, PartialEq)] pub struct UpdateData<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for UpdateData<'a> { + impl<'a> flatbuffers::Follow<'a> for UpdateData<'a> { type Inner = UpdateData<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> UpdateData<'a> { - pub const VT_UPDATE_DATA_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_UPDATE_DATA: ::flatbuffers::VOffsetT = 6; + pub const VT_UPDATE_DATA_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_UPDATE_DATA: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { UpdateData { _tab: table } } #[allow(unused_mut)] @@ -2374,11 +2370,11 @@ pub mod common { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args UpdateDataArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = UpdateDataBuilder::new(_fbb); if let Some(x) = args.update_data { builder.add_update_data(x); @@ -2402,13 +2398,13 @@ pub mod common { } } #[inline] - pub fn update_data(&self) -> ::flatbuffers::Table<'a> { + pub fn update_data(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( UpdateData::VT_UPDATE_DATA, None, ) @@ -2502,21 +2498,22 @@ pub mod common { } } - impl ::flatbuffers::Verifiable for UpdateData<'_> { + impl flatbuffers::Verifiable for UpdateData<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_union::("update_data_type", Self::VT_UPDATE_DATA_TYPE, "update_data", Self::VT_UPDATE_DATA, true, |key, v, pos| { match key { - UpdateDataType::StateUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("UpdateDataType::StateUpdate", pos), - UpdateDataType::DeltaUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("UpdateDataType::DeltaUpdate", pos), - UpdateDataType::StateAndDeltaUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("UpdateDataType::StateAndDeltaUpdate", pos), - UpdateDataType::RelatedStateUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("UpdateDataType::RelatedStateUpdate", pos), - UpdateDataType::RelatedDeltaUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("UpdateDataType::RelatedDeltaUpdate", pos), - UpdateDataType::RelatedStateAndDeltaUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("UpdateDataType::RelatedStateAndDeltaUpdate", pos), + UpdateDataType::StateUpdate => v.verify_union_variant::>("UpdateDataType::StateUpdate", pos), + UpdateDataType::DeltaUpdate => v.verify_union_variant::>("UpdateDataType::DeltaUpdate", pos), + UpdateDataType::StateAndDeltaUpdate => v.verify_union_variant::>("UpdateDataType::StateAndDeltaUpdate", pos), + UpdateDataType::RelatedStateUpdate => v.verify_union_variant::>("UpdateDataType::RelatedStateUpdate", pos), + UpdateDataType::RelatedDeltaUpdate => v.verify_union_variant::>("UpdateDataType::RelatedDeltaUpdate", pos), + UpdateDataType::RelatedStateAndDeltaUpdate => v.verify_union_variant::>("UpdateDataType::RelatedStateAndDeltaUpdate", pos), _ => Ok(()), } })? @@ -2526,7 +2523,7 @@ pub mod common { } pub struct UpdateDataArgs { pub update_data_type: UpdateDataType, - pub update_data: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub update_data: Option>, } impl<'a> Default for UpdateDataArgs { #[inline] @@ -2538,11 +2535,11 @@ pub mod common { } } - pub struct UpdateDataBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct UpdateDataBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UpdateDataBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> UpdateDataBuilder<'a, 'b, A> { #[inline] pub fn add_update_data_type(&mut self, update_data_type: UpdateDataType) { self.fbb_.push_slot::( @@ -2554,16 +2551,16 @@ pub mod common { #[inline] pub fn add_update_data( &mut self, - update_data: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + update_data: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( UpdateData::VT_UPDATE_DATA, update_data, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> UpdateDataBuilder<'a, 'b, A> { let start = _fbb.start_table(); UpdateDataBuilder { @@ -2572,16 +2569,16 @@ pub mod common { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, UpdateData::VT_UPDATE_DATA, "update_data"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for UpdateData<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for UpdateData<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("UpdateData"); ds.field("update_data_type", &self.update_data_type()); match self.update_data_type() { diff --git a/rust/src/generated/host_response_generated.rs b/rust/src/generated/host_response_generated.rs index 115d784..3077c50 100644 --- a/rust/src/generated/host_response_generated.rs +++ b/rust/src/generated/host_response_generated.rs @@ -1,13 +1,23 @@ // automatically generated by the FlatBuffers compiler, do not modify + // @generated -extern crate alloc; use crate::common_generated::*; +use core::cmp::Ordering; +use core::mem; + +extern crate flatbuffers; +use self::flatbuffers::{EndianScalar, Follow}; #[allow(unused_imports, dead_code)] pub mod host_response { use crate::common_generated::*; + use core::cmp::Ordering; + use core::mem; + + extern crate flatbuffers; + use self::flatbuffers::{EndianScalar, Follow}; #[deprecated( since = "2.0.0", @@ -68,8 +78,8 @@ pub mod host_response { } } } - impl ::core::fmt::Debug for ContractResponseType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for ContractResponseType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -77,24 +87,24 @@ pub mod host_response { } } } - impl<'a> ::flatbuffers::Follow<'a> for ContractResponseType { + impl<'a> flatbuffers::Follow<'a> for ContractResponseType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for ContractResponseType { + impl flatbuffers::Push for ContractResponseType { type Output = ContractResponseType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for ContractResponseType { + impl flatbuffers::EndianScalar for ContractResponseType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -108,17 +118,18 @@ pub mod host_response { } } - impl<'a> ::flatbuffers::Verifiable for ContractResponseType { + impl<'a> flatbuffers::Verifiable for ContractResponseType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for ContractResponseType {} + impl flatbuffers::SimpleToVerifyInSlice for ContractResponseType {} pub struct ContractResponseTypeUnionTableOffset {} #[deprecated( @@ -172,8 +183,8 @@ pub mod host_response { } } } - impl ::core::fmt::Debug for OutboundDelegateMsgType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for OutboundDelegateMsgType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -181,24 +192,24 @@ pub mod host_response { } } } - impl<'a> ::flatbuffers::Follow<'a> for OutboundDelegateMsgType { + impl<'a> flatbuffers::Follow<'a> for OutboundDelegateMsgType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for OutboundDelegateMsgType { + impl flatbuffers::Push for OutboundDelegateMsgType { type Output = OutboundDelegateMsgType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for OutboundDelegateMsgType { + impl flatbuffers::EndianScalar for OutboundDelegateMsgType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -212,17 +223,18 @@ pub mod host_response { } } - impl<'a> ::flatbuffers::Verifiable for OutboundDelegateMsgType { + impl<'a> flatbuffers::Verifiable for OutboundDelegateMsgType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for OutboundDelegateMsgType {} + impl flatbuffers::SimpleToVerifyInSlice for OutboundDelegateMsgType {} pub struct OutboundDelegateMsgTypeUnionTableOffset {} #[deprecated( @@ -284,8 +296,8 @@ pub mod host_response { } } } - impl ::core::fmt::Debug for HostResponseType { - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + impl core::fmt::Debug for HostResponseType { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -293,24 +305,24 @@ pub mod host_response { } } } - impl<'a> ::flatbuffers::Follow<'a> for HostResponseType { + impl<'a> flatbuffers::Follow<'a> for HostResponseType { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; + let b = flatbuffers::read_scalar_at::(buf, loc); Self(b) } } - impl ::flatbuffers::Push for HostResponseType { + impl flatbuffers::Push for HostResponseType { type Output = HostResponseType; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; + flatbuffers::emplace_scalar::(dst, self.0); } } - impl ::flatbuffers::EndianScalar for HostResponseType { + impl flatbuffers::EndianScalar for HostResponseType { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -324,43 +336,44 @@ pub mod host_response { } } - impl<'a> ::flatbuffers::Verifiable for HostResponseType { + impl<'a> flatbuffers::Verifiable for HostResponseType { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; u8::run_verifier(v, pos) } } - impl ::flatbuffers::SimpleToVerifyInSlice for HostResponseType {} + impl flatbuffers::SimpleToVerifyInSlice for HostResponseType {} pub struct HostResponseTypeUnionTableOffset {} pub enum GetResponseOffset {} #[derive(Copy, Clone, PartialEq)] pub struct GetResponse<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for GetResponse<'a> { + impl<'a> flatbuffers::Follow<'a> for GetResponse<'a> { type Inner = GetResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> GetResponse<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_CONTRACT: ::flatbuffers::VOffsetT = 6; - pub const VT_STATE: ::flatbuffers::VOffsetT = 8; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_CONTRACT: flatbuffers::VOffsetT = 6; + pub const VT_STATE: flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { GetResponse { _tab: table } } #[allow(unused_mut)] @@ -368,11 +381,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args GetResponseArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = GetResponseBuilder::new(_fbb); if let Some(x) = args.state { builder.add_state(x); @@ -393,7 +406,7 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( GetResponse::VT_KEY, None, ) @@ -407,20 +420,20 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( GetResponse::VT_CONTRACT, None, ) } } #[inline] - pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn state(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( GetResponse::VT_STATE, None, ) @@ -429,24 +442,25 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for GetResponse<'_> { + impl flatbuffers::Verifiable for GetResponse<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "contract", Self::VT_CONTRACT, false, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "state", Self::VT_STATE, true, @@ -456,9 +470,9 @@ pub mod host_response { } } pub struct GetResponseArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, - pub contract: Option<::flatbuffers::WIPOffset>>, - pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub key: Option>>, + pub contract: Option>>, + pub state: Option>>, } impl<'a> Default for GetResponseArgs<'a> { #[inline] @@ -471,15 +485,15 @@ pub mod host_response { } } - pub struct GetResponseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct GetResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GetResponseBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> GetResponseBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( GetResponse::VT_KEY, key, ); @@ -487,25 +501,22 @@ pub mod host_response { #[inline] pub fn add_contract( &mut self, - contract: ::flatbuffers::WIPOffset>, + contract: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( GetResponse::VT_CONTRACT, contract, ); } #[inline] - pub fn add_state( - &mut self, - state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, - ) { + pub fn add_state(&mut self, state: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(GetResponse::VT_STATE, state); + .push_slot_always::>(GetResponse::VT_STATE, state); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> GetResponseBuilder<'a, 'b, A> { let start = _fbb.start_table(); GetResponseBuilder { @@ -514,16 +525,16 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, GetResponse::VT_KEY, "key"); self.fbb_.required(o, GetResponse::VT_STATE, "state"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for GetResponse<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for GetResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("GetResponse"); ds.field("key", &self.key()); ds.field("contract", &self.contract()); @@ -535,24 +546,24 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct PutResponse<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for PutResponse<'a> { + impl<'a> flatbuffers::Follow<'a> for PutResponse<'a> { type Inner = PutResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> PutResponse<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; + pub const VT_KEY: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { PutResponse { _tab: table } } #[allow(unused_mut)] @@ -560,11 +571,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args PutResponseArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = PutResponseBuilder::new(_fbb); if let Some(x) = args.key { builder.add_key(x); @@ -579,7 +590,7 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( PutResponse::VT_KEY, None, ) @@ -588,14 +599,15 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for PutResponse<'_> { + impl flatbuffers::Verifiable for PutResponse<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, @@ -605,7 +617,7 @@ pub mod host_response { } } pub struct PutResponseArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, + pub key: Option>>, } impl<'a> Default for PutResponseArgs<'a> { #[inline] @@ -616,22 +628,22 @@ pub mod host_response { } } - pub struct PutResponseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct PutResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PutResponseBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> PutResponseBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( PutResponse::VT_KEY, key, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> PutResponseBuilder<'a, 'b, A> { let start = _fbb.start_table(); PutResponseBuilder { @@ -640,15 +652,15 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, PutResponse::VT_KEY, "key"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for PutResponse<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for PutResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("PutResponse"); ds.field("key", &self.key()); ds.finish() @@ -658,25 +670,25 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct UpdateNotification<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for UpdateNotification<'a> { + impl<'a> flatbuffers::Follow<'a> for UpdateNotification<'a> { type Inner = UpdateNotification<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> UpdateNotification<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_UPDATE: ::flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_UPDATE: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { UpdateNotification { _tab: table } } #[allow(unused_mut)] @@ -684,11 +696,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args UpdateNotificationArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = UpdateNotificationBuilder::new(_fbb); if let Some(x) = args.update { builder.add_update(x); @@ -706,7 +718,7 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( UpdateNotification::VT_KEY, None, ) @@ -720,7 +732,7 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( UpdateNotification::VT_UPDATE, None, ) @@ -729,19 +741,20 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for UpdateNotification<'_> { + impl flatbuffers::Verifiable for UpdateNotification<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "update", Self::VT_UPDATE, true, @@ -751,8 +764,8 @@ pub mod host_response { } } pub struct UpdateNotificationArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, - pub update: Option<::flatbuffers::WIPOffset>>, + pub key: Option>>, + pub update: Option>>, } impl<'a> Default for UpdateNotificationArgs<'a> { #[inline] @@ -764,15 +777,15 @@ pub mod host_response { } } - pub struct UpdateNotificationBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct UpdateNotificationBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UpdateNotificationBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> UpdateNotificationBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( UpdateNotification::VT_KEY, key, ); @@ -780,17 +793,17 @@ pub mod host_response { #[inline] pub fn add_update( &mut self, - update: ::flatbuffers::WIPOffset>, + update: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( UpdateNotification::VT_UPDATE, update, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> UpdateNotificationBuilder<'a, 'b, A> { let start = _fbb.start_table(); UpdateNotificationBuilder { @@ -799,17 +812,17 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, UpdateNotification::VT_KEY, "key"); self.fbb_ .required(o, UpdateNotification::VT_UPDATE, "update"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for UpdateNotification<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for UpdateNotification<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("UpdateNotification"); ds.field("key", &self.key()); ds.field("update", &self.update()); @@ -820,25 +833,25 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct UpdateResponse<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for UpdateResponse<'a> { + impl<'a> flatbuffers::Follow<'a> for UpdateResponse<'a> { type Inner = UpdateResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> UpdateResponse<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_SUMMARY: ::flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_SUMMARY: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { UpdateResponse { _tab: table } } #[allow(unused_mut)] @@ -846,11 +859,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args UpdateResponseArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = UpdateResponseBuilder::new(_fbb); if let Some(x) = args.summary { builder.add_summary(x); @@ -868,7 +881,7 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( UpdateResponse::VT_KEY, None, ) @@ -876,13 +889,13 @@ pub mod host_response { } } #[inline] - pub fn summary(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn summary(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( UpdateResponse::VT_SUMMARY, None, ) @@ -891,19 +904,20 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for UpdateResponse<'_> { + impl flatbuffers::Verifiable for UpdateResponse<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "summary", Self::VT_SUMMARY, true, @@ -913,8 +927,8 @@ pub mod host_response { } } pub struct UpdateResponseArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, - pub summary: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub key: Option>>, + pub summary: Option>>, } impl<'a> Default for UpdateResponseArgs<'a> { #[inline] @@ -926,15 +940,15 @@ pub mod host_response { } } - pub struct UpdateResponseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct UpdateResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UpdateResponseBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> UpdateResponseBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( UpdateResponse::VT_KEY, key, ); @@ -942,16 +956,14 @@ pub mod host_response { #[inline] pub fn add_summary( &mut self, - summary: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + summary: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( - UpdateResponse::VT_SUMMARY, - summary, - ); + self.fbb_ + .push_slot_always::>(UpdateResponse::VT_SUMMARY, summary); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> UpdateResponseBuilder<'a, 'b, A> { let start = _fbb.start_table(); UpdateResponseBuilder { @@ -960,16 +972,16 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, UpdateResponse::VT_KEY, "key"); self.fbb_.required(o, UpdateResponse::VT_SUMMARY, "summary"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for UpdateResponse<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for UpdateResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("UpdateResponse"); ds.field("key", &self.key()); ds.field("summary", &self.summary()); @@ -980,24 +992,24 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct NotFound<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for NotFound<'a> { + impl<'a> flatbuffers::Follow<'a> for NotFound<'a> { type Inner = NotFound<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> NotFound<'a> { - pub const VT_INSTANCE_ID: ::flatbuffers::VOffsetT = 4; + pub const VT_INSTANCE_ID: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { NotFound { _tab: table } } #[allow(unused_mut)] @@ -1005,11 +1017,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args NotFoundArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = NotFoundBuilder::new(_fbb); if let Some(x) = args.instance_id { builder.add_instance_id(x); @@ -1024,7 +1036,7 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( NotFound::VT_INSTANCE_ID, None, ) @@ -1033,14 +1045,15 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for NotFound<'_> { + impl flatbuffers::Verifiable for NotFound<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "instance_id", Self::VT_INSTANCE_ID, true, @@ -1050,7 +1063,7 @@ pub mod host_response { } } pub struct NotFoundArgs<'a> { - pub instance_id: Option<::flatbuffers::WIPOffset>>, + pub instance_id: Option>>, } impl<'a> Default for NotFoundArgs<'a> { #[inline] @@ -1061,25 +1074,25 @@ pub mod host_response { } } - pub struct NotFoundBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct NotFoundBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> NotFoundBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> NotFoundBuilder<'a, 'b, A> { #[inline] pub fn add_instance_id( &mut self, - instance_id: ::flatbuffers::WIPOffset>, + instance_id: flatbuffers::WIPOffset>, ) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( NotFound::VT_INSTANCE_ID, instance_id, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> NotFoundBuilder<'a, 'b, A> { let start = _fbb.start_table(); NotFoundBuilder { @@ -1088,16 +1101,16 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, NotFound::VT_INSTANCE_ID, "instance_id"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for NotFound<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for NotFound<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("NotFound"); ds.field("instance_id", &self.instance_id()); ds.finish() @@ -1107,25 +1120,25 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct ContractResponse<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ContractResponse<'a> { + impl<'a> flatbuffers::Follow<'a> for ContractResponse<'a> { type Inner = ContractResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ContractResponse<'a> { - pub const VT_CONTRACT_RESPONSE_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_CONTRACT_RESPONSE: ::flatbuffers::VOffsetT = 6; + pub const VT_CONTRACT_RESPONSE_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_CONTRACT_RESPONSE: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ContractResponse { _tab: table } } #[allow(unused_mut)] @@ -1133,11 +1146,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ContractResponseArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ContractResponseBuilder::new(_fbb); if let Some(x) = args.contract_response { builder.add_contract_response(x); @@ -1161,13 +1174,13 @@ pub mod host_response { } } #[inline] - pub fn contract_response(&self) -> ::flatbuffers::Table<'a> { + pub fn contract_response(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( ContractResponse::VT_CONTRACT_RESPONSE, None, ) @@ -1245,20 +1258,21 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for ContractResponse<'_> { + impl flatbuffers::Verifiable for ContractResponse<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_union::("contract_response_type", Self::VT_CONTRACT_RESPONSE_TYPE, "contract_response", Self::VT_CONTRACT_RESPONSE, true, |key, v, pos| { match key { - ContractResponseType::GetResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("ContractResponseType::GetResponse", pos), - ContractResponseType::PutResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("ContractResponseType::PutResponse", pos), - ContractResponseType::UpdateNotification => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("ContractResponseType::UpdateNotification", pos), - ContractResponseType::UpdateResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("ContractResponseType::UpdateResponse", pos), - ContractResponseType::NotFound => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("ContractResponseType::NotFound", pos), + ContractResponseType::GetResponse => v.verify_union_variant::>("ContractResponseType::GetResponse", pos), + ContractResponseType::PutResponse => v.verify_union_variant::>("ContractResponseType::PutResponse", pos), + ContractResponseType::UpdateNotification => v.verify_union_variant::>("ContractResponseType::UpdateNotification", pos), + ContractResponseType::UpdateResponse => v.verify_union_variant::>("ContractResponseType::UpdateResponse", pos), + ContractResponseType::NotFound => v.verify_union_variant::>("ContractResponseType::NotFound", pos), _ => Ok(()), } })? @@ -1268,7 +1282,7 @@ pub mod host_response { } pub struct ContractResponseArgs { pub contract_response_type: ContractResponseType, - pub contract_response: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub contract_response: Option>, } impl<'a> Default for ContractResponseArgs { #[inline] @@ -1280,11 +1294,11 @@ pub mod host_response { } } - pub struct ContractResponseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ContractResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractResponseBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ContractResponseBuilder<'a, 'b, A> { #[inline] pub fn add_contract_response_type(&mut self, contract_response_type: ContractResponseType) { self.fbb_.push_slot::( @@ -1296,16 +1310,16 @@ pub mod host_response { #[inline] pub fn add_contract_response( &mut self, - contract_response: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + contract_response: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( ContractResponse::VT_CONTRACT_RESPONSE, contract_response, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ContractResponseBuilder<'a, 'b, A> { let start = _fbb.start_table(); ContractResponseBuilder { @@ -1314,19 +1328,19 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required( o, ContractResponse::VT_CONTRACT_RESPONSE, "contract_response", ); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ContractResponse<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ContractResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ContractResponse"); ds.field("contract_response_type", &self.contract_response_type()); match self.contract_response_type() { @@ -1392,25 +1406,25 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct DelegateKey<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for DelegateKey<'a> { + impl<'a> flatbuffers::Follow<'a> for DelegateKey<'a> { type Inner = DelegateKey<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> DelegateKey<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_CODE_HASH: ::flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_CODE_HASH: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { DelegateKey { _tab: table } } #[allow(unused_mut)] @@ -1418,11 +1432,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args DelegateKeyArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = DelegateKeyBuilder::new(_fbb); if let Some(x) = args.code_hash { builder.add_code_hash(x); @@ -1434,13 +1448,13 @@ pub mod host_response { } #[inline] - pub fn key(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn key(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( DelegateKey::VT_KEY, None, ) @@ -1448,13 +1462,13 @@ pub mod host_response { } } #[inline] - pub fn code_hash(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn code_hash(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( DelegateKey::VT_CODE_HASH, None, ) @@ -1463,19 +1477,20 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for DelegateKey<'_> { + impl flatbuffers::Verifiable for DelegateKey<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "code_hash", Self::VT_CODE_HASH, true, @@ -1485,8 +1500,8 @@ pub mod host_response { } } pub struct DelegateKeyArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, - pub code_hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub key: Option>>, + pub code_hash: Option>>, } impl<'a> Default for DelegateKeyArgs<'a> { #[inline] @@ -1498,29 +1513,29 @@ pub mod host_response { } } - pub struct DelegateKeyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct DelegateKeyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateKeyBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> DelegateKeyBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(DelegateKey::VT_KEY, key); + .push_slot_always::>(DelegateKey::VT_KEY, key); } #[inline] pub fn add_code_hash( &mut self, - code_hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + code_hash: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( DelegateKey::VT_CODE_HASH, code_hash, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> DelegateKeyBuilder<'a, 'b, A> { let start = _fbb.start_table(); DelegateKeyBuilder { @@ -1529,17 +1544,17 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, DelegateKey::VT_KEY, "key"); self.fbb_ .required(o, DelegateKey::VT_CODE_HASH, "code_hash"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for DelegateKey<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for DelegateKey<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("DelegateKey"); ds.field("key", &self.key()); ds.field("code_hash", &self.code_hash()); @@ -1550,26 +1565,26 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct UserInputRequest<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for UserInputRequest<'a> { + impl<'a> flatbuffers::Follow<'a> for UserInputRequest<'a> { type Inner = UserInputRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> UserInputRequest<'a> { - pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 4; - pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 6; - pub const VT_RESPONSES: ::flatbuffers::VOffsetT = 8; + pub const VT_REQUEST_ID: flatbuffers::VOffsetT = 4; + pub const VT_MESSAGE: flatbuffers::VOffsetT = 6; + pub const VT_RESPONSES: flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { UserInputRequest { _tab: table } } #[allow(unused_mut)] @@ -1577,11 +1592,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args UserInputRequestArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = UserInputRequestBuilder::new(_fbb); if let Some(x) = args.responses { builder.add_responses(x); @@ -1605,13 +1620,13 @@ pub mod host_response { } } #[inline] - pub fn message(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn message(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( UserInputRequest::VT_MESSAGE, None, ) @@ -1621,35 +1636,36 @@ pub mod host_response { #[inline] pub fn responses( &self, - ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>> { + ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>, + .get::>, >>(UserInputRequest::VT_RESPONSES, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for UserInputRequest<'_> { + impl flatbuffers::Verifiable for UserInputRequest<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::("request_id", Self::VT_REQUEST_ID, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "message", Self::VT_MESSAGE, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>, + .visit_field::>, >>("responses", Self::VT_RESPONSES, true)? .finish(); Ok(()) @@ -1657,10 +1673,10 @@ pub mod host_response { } pub struct UserInputRequestArgs<'a> { pub request_id: u32, - pub message: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub message: Option>>, pub responses: Option< - ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>, + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, >, >, } @@ -1675,11 +1691,11 @@ pub mod host_response { } } - pub struct UserInputRequestBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct UserInputRequestBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UserInputRequestBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> UserInputRequestBuilder<'a, 'b, A> { #[inline] pub fn add_request_id(&mut self, request_id: u32) { self.fbb_ @@ -1688,9 +1704,9 @@ pub mod host_response { #[inline] pub fn add_message( &mut self, - message: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + message: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( UserInputRequest::VT_MESSAGE, message, ); @@ -1698,18 +1714,18 @@ pub mod host_response { #[inline] pub fn add_responses( &mut self, - responses: ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset>>, + responses: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, >, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( UserInputRequest::VT_RESPONSES, responses, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> UserInputRequestBuilder<'a, 'b, A> { let start = _fbb.start_table(); UserInputRequestBuilder { @@ -1718,18 +1734,18 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, UserInputRequest::VT_MESSAGE, "message"); self.fbb_ .required(o, UserInputRequest::VT_RESPONSES, "responses"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for UserInputRequest<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for UserInputRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("UserInputRequest"); ds.field("request_id", &self.request_id()); ds.field("message", &self.message()); @@ -1741,24 +1757,24 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct ClientResponse<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ClientResponse<'a> { + impl<'a> flatbuffers::Follow<'a> for ClientResponse<'a> { type Inner = ClientResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ClientResponse<'a> { - pub const VT_DATA: ::flatbuffers::VOffsetT = 4; + pub const VT_DATA: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ClientResponse { _tab: table } } #[allow(unused_mut)] @@ -1766,11 +1782,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ClientResponseArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ClientResponseBuilder::new(_fbb); if let Some(x) = args.data { builder.add_data(x); @@ -1779,13 +1795,13 @@ pub mod host_response { } #[inline] - pub fn data(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + pub fn data(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ClientResponse::VT_DATA, None, ) @@ -1793,14 +1809,15 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for ClientResponse<'_> { + impl flatbuffers::Verifiable for ClientResponse<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "data", Self::VT_DATA, false, @@ -1810,7 +1827,7 @@ pub mod host_response { } } pub struct ClientResponseArgs<'a> { - pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub data: Option>>, } impl<'a> Default for ClientResponseArgs<'a> { #[inline] @@ -1819,19 +1836,19 @@ pub mod host_response { } } - pub struct ClientResponseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ClientResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ClientResponseBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ClientResponseBuilder<'a, 'b, A> { #[inline] - pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) { + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(ClientResponse::VT_DATA, data); + .push_slot_always::>(ClientResponse::VT_DATA, data); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ClientResponseBuilder<'a, 'b, A> { let start = _fbb.start_table(); ClientResponseBuilder { @@ -1840,14 +1857,14 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ClientResponse<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ClientResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ClientResponse"); ds.field("data", &self.data()); ds.finish() @@ -1857,26 +1874,26 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct RequestUserInput<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for RequestUserInput<'a> { + impl<'a> flatbuffers::Follow<'a> for RequestUserInput<'a> { type Inner = RequestUserInput<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> RequestUserInput<'a> { - pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 4; - pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 6; - pub const VT_RESPONSES: ::flatbuffers::VOffsetT = 8; + pub const VT_REQUEST_ID: flatbuffers::VOffsetT = 4; + pub const VT_MESSAGE: flatbuffers::VOffsetT = 6; + pub const VT_RESPONSES: flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { RequestUserInput { _tab: table } } #[allow(unused_mut)] @@ -1884,11 +1901,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args RequestUserInputArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = RequestUserInputBuilder::new(_fbb); if let Some(x) = args.responses { builder.add_responses(x); @@ -1912,13 +1929,13 @@ pub mod host_response { } } #[inline] - pub fn message(&self) -> Option<::flatbuffers::Vector<'a, u8>> { + pub fn message(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( RequestUserInput::VT_MESSAGE, None, ) @@ -1927,35 +1944,36 @@ pub mod host_response { #[inline] pub fn responses( &self, - ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>> { + ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>, + .get::>, >>(RequestUserInput::VT_RESPONSES, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for RequestUserInput<'_> { + impl flatbuffers::Verifiable for RequestUserInput<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::("request_id", Self::VT_REQUEST_ID, false)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "message", Self::VT_MESSAGE, false, )? - .visit_field::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>, + .visit_field::>, >>("responses", Self::VT_RESPONSES, true)? .finish(); Ok(()) @@ -1963,10 +1981,10 @@ pub mod host_response { } pub struct RequestUserInputArgs<'a> { pub request_id: u32, - pub message: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub message: Option>>, pub responses: Option< - ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>, + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, >, >, } @@ -1981,11 +1999,11 @@ pub mod host_response { } } - pub struct RequestUserInputBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct RequestUserInputBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RequestUserInputBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> RequestUserInputBuilder<'a, 'b, A> { #[inline] pub fn add_request_id(&mut self, request_id: u32) { self.fbb_ @@ -1994,9 +2012,9 @@ pub mod host_response { #[inline] pub fn add_message( &mut self, - message: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + message: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( RequestUserInput::VT_MESSAGE, message, ); @@ -2004,18 +2022,18 @@ pub mod host_response { #[inline] pub fn add_responses( &mut self, - responses: ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset>>, + responses: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, >, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( RequestUserInput::VT_RESPONSES, responses, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> RequestUserInputBuilder<'a, 'b, A> { let start = _fbb.start_table(); RequestUserInputBuilder { @@ -2024,16 +2042,16 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, RequestUserInput::VT_RESPONSES, "responses"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for RequestUserInput<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for RequestUserInput<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("RequestUserInput"); ds.field("request_id", &self.request_id()); ds.field("message", &self.message()); @@ -2045,24 +2063,24 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct ContextUpdated<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for ContextUpdated<'a> { + impl<'a> flatbuffers::Follow<'a> for ContextUpdated<'a> { type Inner = ContextUpdated<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> ContextUpdated<'a> { - pub const VT_CONTEXT: ::flatbuffers::VOffsetT = 4; + pub const VT_CONTEXT: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { ContextUpdated { _tab: table } } #[allow(unused_mut)] @@ -2070,11 +2088,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ContextUpdatedArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ContextUpdatedBuilder::new(_fbb); if let Some(x) = args.context { builder.add_context(x); @@ -2083,13 +2101,13 @@ pub mod host_response { } #[inline] - pub fn context(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn context(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( ContextUpdated::VT_CONTEXT, None, ) @@ -2098,14 +2116,15 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for ContextUpdated<'_> { + impl flatbuffers::Verifiable for ContextUpdated<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "context", Self::VT_CONTEXT, true, @@ -2115,7 +2134,7 @@ pub mod host_response { } } pub struct ContextUpdatedArgs<'a> { - pub context: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub context: Option>>, } impl<'a> Default for ContextUpdatedArgs<'a> { #[inline] @@ -2126,24 +2145,22 @@ pub mod host_response { } } - pub struct ContextUpdatedBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ContextUpdatedBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContextUpdatedBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ContextUpdatedBuilder<'a, 'b, A> { #[inline] pub fn add_context( &mut self, - context: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + context: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( - ContextUpdated::VT_CONTEXT, - context, - ); + self.fbb_ + .push_slot_always::>(ContextUpdated::VT_CONTEXT, context); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> ContextUpdatedBuilder<'a, 'b, A> { let start = _fbb.start_table(); ContextUpdatedBuilder { @@ -2152,15 +2169,15 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, ContextUpdated::VT_CONTEXT, "context"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for ContextUpdated<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for ContextUpdated<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ContextUpdated"); ds.field("context", &self.context()); ds.finish() @@ -2170,25 +2187,25 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct OutboundDelegateMsg<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for OutboundDelegateMsg<'a> { + impl<'a> flatbuffers::Follow<'a> for OutboundDelegateMsg<'a> { type Inner = OutboundDelegateMsg<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> OutboundDelegateMsg<'a> { - pub const VT_INBOUND_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_INBOUND: ::flatbuffers::VOffsetT = 6; + pub const VT_INBOUND_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_INBOUND: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { OutboundDelegateMsg { _tab: table } } #[allow(unused_mut)] @@ -2196,11 +2213,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args OutboundDelegateMsgArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = OutboundDelegateMsgBuilder::new(_fbb); if let Some(x) = args.inbound { builder.add_inbound(x); @@ -2224,13 +2241,13 @@ pub mod host_response { } } #[inline] - pub fn inbound(&self) -> ::flatbuffers::Table<'a> { + pub fn inbound(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( OutboundDelegateMsg::VT_INBOUND, None, ) @@ -2282,18 +2299,19 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for OutboundDelegateMsg<'_> { + impl flatbuffers::Verifiable for OutboundDelegateMsg<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_union::("inbound_type", Self::VT_INBOUND_TYPE, "inbound", Self::VT_INBOUND, true, |key, v, pos| { match key { - OutboundDelegateMsgType::common_ApplicationMessage => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("OutboundDelegateMsgType::common_ApplicationMessage", pos), - OutboundDelegateMsgType::RequestUserInput => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("OutboundDelegateMsgType::RequestUserInput", pos), - OutboundDelegateMsgType::ContextUpdated => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("OutboundDelegateMsgType::ContextUpdated", pos), + OutboundDelegateMsgType::common_ApplicationMessage => v.verify_union_variant::>("OutboundDelegateMsgType::common_ApplicationMessage", pos), + OutboundDelegateMsgType::RequestUserInput => v.verify_union_variant::>("OutboundDelegateMsgType::RequestUserInput", pos), + OutboundDelegateMsgType::ContextUpdated => v.verify_union_variant::>("OutboundDelegateMsgType::ContextUpdated", pos), _ => Ok(()), } })? @@ -2303,7 +2321,7 @@ pub mod host_response { } pub struct OutboundDelegateMsgArgs { pub inbound_type: OutboundDelegateMsgType, - pub inbound: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub inbound: Option>, } impl<'a> Default for OutboundDelegateMsgArgs { #[inline] @@ -2315,11 +2333,11 @@ pub mod host_response { } } - pub struct OutboundDelegateMsgBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct OutboundDelegateMsgBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> OutboundDelegateMsgBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> OutboundDelegateMsgBuilder<'a, 'b, A> { #[inline] pub fn add_inbound_type(&mut self, inbound_type: OutboundDelegateMsgType) { self.fbb_.push_slot::( @@ -2331,16 +2349,16 @@ pub mod host_response { #[inline] pub fn add_inbound( &mut self, - inbound: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + inbound: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( OutboundDelegateMsg::VT_INBOUND, inbound, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> OutboundDelegateMsgBuilder<'a, 'b, A> { let start = _fbb.start_table(); OutboundDelegateMsgBuilder { @@ -2349,16 +2367,16 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, OutboundDelegateMsg::VT_INBOUND, "inbound"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for OutboundDelegateMsg<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for OutboundDelegateMsg<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("OutboundDelegateMsg"); ds.field("inbound_type", &self.inbound_type()); match self.inbound_type() { @@ -2404,25 +2422,25 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct DelegateResponse<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for DelegateResponse<'a> { + impl<'a> flatbuffers::Follow<'a> for DelegateResponse<'a> { type Inner = DelegateResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> DelegateResponse<'a> { - pub const VT_KEY: ::flatbuffers::VOffsetT = 4; - pub const VT_VALUES: ::flatbuffers::VOffsetT = 6; + pub const VT_KEY: flatbuffers::VOffsetT = 4; + pub const VT_VALUES: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { DelegateResponse { _tab: table } } #[allow(unused_mut)] @@ -2430,11 +2448,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args DelegateResponseArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = DelegateResponseBuilder::new(_fbb); if let Some(x) = args.values { builder.add_values(x); @@ -2452,7 +2470,7 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset>( + .get::>( DelegateResponse::VT_KEY, None, ) @@ -2462,48 +2480,46 @@ pub mod host_response { #[inline] pub fn values( &self, - ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>> + ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector< - 'a, - ::flatbuffers::ForwardsUOffset, - >, + .get::>, >>(DelegateResponse::VT_VALUES, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for DelegateResponse<'_> { + impl flatbuffers::Verifiable for DelegateResponse<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset>( + .visit_field::>( "key", Self::VT_KEY, true, )? - .visit_field::<::flatbuffers::ForwardsUOffset< - ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>, + .visit_field::>, >>("values", Self::VT_VALUES, true)? .finish(); Ok(()) } } pub struct DelegateResponseArgs<'a> { - pub key: Option<::flatbuffers::WIPOffset>>, + pub key: Option>>, pub values: Option< - ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>, + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, >, >, } @@ -2517,15 +2533,15 @@ pub mod host_response { } } - pub struct DelegateResponseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct DelegateResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateResponseBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> DelegateResponseBuilder<'a, 'b, A> { #[inline] - pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset>) { + pub fn add_key(&mut self, key: flatbuffers::WIPOffset>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset>( + .push_slot_always::>( DelegateResponse::VT_KEY, key, ); @@ -2533,18 +2549,16 @@ pub mod host_response { #[inline] pub fn add_values( &mut self, - values: ::flatbuffers::WIPOffset< - ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset>>, + values: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, >, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( - DelegateResponse::VT_VALUES, - values, - ); + self.fbb_ + .push_slot_always::>(DelegateResponse::VT_VALUES, values); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> DelegateResponseBuilder<'a, 'b, A> { let start = _fbb.start_table(); DelegateResponseBuilder { @@ -2553,16 +2567,16 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, DelegateResponse::VT_KEY, "key"); self.fbb_.required(o, DelegateResponse::VT_VALUES, "values"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for DelegateResponse<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for DelegateResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("DelegateResponse"); ds.field("key", &self.key()); ds.field("values", &self.values()); @@ -2573,24 +2587,24 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct GenerateRandData<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for GenerateRandData<'a> { + impl<'a> flatbuffers::Follow<'a> for GenerateRandData<'a> { type Inner = GenerateRandData<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> GenerateRandData<'a> { - pub const VT_WRAPPED_STATE: ::flatbuffers::VOffsetT = 4; + pub const VT_WRAPPED_STATE: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { GenerateRandData { _tab: table } } #[allow(unused_mut)] @@ -2598,11 +2612,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args GenerateRandDataArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = GenerateRandDataBuilder::new(_fbb); if let Some(x) = args.wrapped_state { builder.add_wrapped_state(x); @@ -2611,13 +2625,13 @@ pub mod host_response { } #[inline] - pub fn wrapped_state(&self) -> ::flatbuffers::Vector<'a, u8> { + pub fn wrapped_state(&self) -> flatbuffers::Vector<'a, u8> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>( + .get::>>( GenerateRandData::VT_WRAPPED_STATE, None, ) @@ -2626,14 +2640,15 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for GenerateRandData<'_> { + impl flatbuffers::Verifiable for GenerateRandData<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>( + .visit_field::>>( "wrapped_state", Self::VT_WRAPPED_STATE, true, @@ -2643,7 +2658,7 @@ pub mod host_response { } } pub struct GenerateRandDataArgs<'a> { - pub wrapped_state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>, + pub wrapped_state: Option>>, } impl<'a> Default for GenerateRandDataArgs<'a> { #[inline] @@ -2654,24 +2669,24 @@ pub mod host_response { } } - pub struct GenerateRandDataBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct GenerateRandDataBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GenerateRandDataBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> GenerateRandDataBuilder<'a, 'b, A> { #[inline] pub fn add_wrapped_state( &mut self, - wrapped_state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>, + wrapped_state: flatbuffers::WIPOffset>, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( + self.fbb_.push_slot_always::>( GenerateRandData::VT_WRAPPED_STATE, wrapped_state, ); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> GenerateRandDataBuilder<'a, 'b, A> { let start = _fbb.start_table(); GenerateRandDataBuilder { @@ -2680,16 +2695,16 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_ .required(o, GenerateRandData::VT_WRAPPED_STATE, "wrapped_state"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for GenerateRandData<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for GenerateRandData<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("GenerateRandData"); ds.field("wrapped_state", &self.wrapped_state()); ds.finish() @@ -2699,24 +2714,24 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct Ok<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for Ok<'a> { + impl<'a> flatbuffers::Follow<'a> for Ok<'a> { type Inner = Ok<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> Ok<'a> { - pub const VT_MSG: ::flatbuffers::VOffsetT = 4; + pub const VT_MSG: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Ok { _tab: table } } #[allow(unused_mut)] @@ -2724,11 +2739,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args OkArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = OkBuilder::new(_fbb); if let Some(x) = args.msg { builder.add_msg(x); @@ -2743,26 +2758,27 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<&str>>(Ok::VT_MSG, None) + .get::>(Ok::VT_MSG, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for Ok<'_> { + impl flatbuffers::Verifiable for Ok<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("msg", Self::VT_MSG, true)? + .visit_field::>("msg", Self::VT_MSG, true)? .finish(); Ok(()) } } pub struct OkArgs<'a> { - pub msg: Option<::flatbuffers::WIPOffset<&'a str>>, + pub msg: Option>, } impl<'a> Default for OkArgs<'a> { #[inline] @@ -2773,18 +2789,18 @@ pub mod host_response { } } - pub struct OkBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct OkBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> OkBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> OkBuilder<'a, 'b, A> { #[inline] - pub fn add_msg(&mut self, msg: ::flatbuffers::WIPOffset<&'b str>) { + pub fn add_msg(&mut self, msg: flatbuffers::WIPOffset<&'b str>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(Ok::VT_MSG, msg); + .push_slot_always::>(Ok::VT_MSG, msg); } #[inline] - pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> OkBuilder<'a, 'b, A> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> OkBuilder<'a, 'b, A> { let start = _fbb.start_table(); OkBuilder { fbb_: _fbb, @@ -2792,15 +2808,15 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, Ok::VT_MSG, "msg"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for Ok<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for Ok<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("Ok"); ds.field("msg", &self.msg()); ds.finish() @@ -2810,24 +2826,24 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct Error<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for Error<'a> { + impl<'a> flatbuffers::Follow<'a> for Error<'a> { type Inner = Error<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> Error<'a> { - pub const VT_MSG: ::flatbuffers::VOffsetT = 4; + pub const VT_MSG: flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { Error { _tab: table } } #[allow(unused_mut)] @@ -2835,11 +2851,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args ErrorArgs<'args>, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = ErrorBuilder::new(_fbb); if let Some(x) = args.msg { builder.add_msg(x); @@ -2854,26 +2870,27 @@ pub mod host_response { // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<&str>>(Error::VT_MSG, None) + .get::>(Error::VT_MSG, None) .unwrap() } } } - impl ::flatbuffers::Verifiable for Error<'_> { + impl flatbuffers::Verifiable for Error<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("msg", Self::VT_MSG, true)? + .visit_field::>("msg", Self::VT_MSG, true)? .finish(); Ok(()) } } pub struct ErrorArgs<'a> { - pub msg: Option<::flatbuffers::WIPOffset<&'a str>>, + pub msg: Option>, } impl<'a> Default for ErrorArgs<'a> { #[inline] @@ -2884,20 +2901,18 @@ pub mod host_response { } } - pub struct ErrorBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct ErrorBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ErrorBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> ErrorBuilder<'a, 'b, A> { #[inline] - pub fn add_msg(&mut self, msg: ::flatbuffers::WIPOffset<&'b str>) { + pub fn add_msg(&mut self, msg: flatbuffers::WIPOffset<&'b str>) { self.fbb_ - .push_slot_always::<::flatbuffers::WIPOffset<_>>(Error::VT_MSG, msg); + .push_slot_always::>(Error::VT_MSG, msg); } #[inline] - pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - ) -> ErrorBuilder<'a, 'b, A> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ErrorBuilder<'a, 'b, A> { let start = _fbb.start_table(); ErrorBuilder { fbb_: _fbb, @@ -2905,15 +2920,15 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, Error::VT_MSG, "msg"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for Error<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for Error<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("Error"); ds.field("msg", &self.msg()); ds.finish() @@ -2923,25 +2938,25 @@ pub mod host_response { #[derive(Copy, Clone, PartialEq)] pub struct HostResponse<'a> { - pub _tab: ::flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } - impl<'a> ::flatbuffers::Follow<'a> for HostResponse<'a> { + impl<'a> flatbuffers::Follow<'a> for HostResponse<'a> { type Inner = HostResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, + _tab: flatbuffers::Table::new(buf, loc), } } } impl<'a> HostResponse<'a> { - pub const VT_RESPONSE_TYPE: ::flatbuffers::VOffsetT = 4; - pub const VT_RESPONSE: ::flatbuffers::VOffsetT = 6; + pub const VT_RESPONSE_TYPE: flatbuffers::VOffsetT = 4; + pub const VT_RESPONSE: flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { HostResponse { _tab: table } } #[allow(unused_mut)] @@ -2949,11 +2964,11 @@ pub mod host_response { 'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, - A: ::flatbuffers::Allocator + 'bldr, + A: flatbuffers::Allocator + 'bldr, >( - _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args HostResponseArgs, - ) -> ::flatbuffers::WIPOffset> { + ) -> flatbuffers::WIPOffset> { let mut builder = HostResponseBuilder::new(_fbb); if let Some(x) = args.response { builder.add_response(x); @@ -2977,13 +2992,13 @@ pub mod host_response { } } #[inline] - pub fn response(&self) -> ::flatbuffers::Table<'a> { + pub fn response(&self) -> flatbuffers::Table<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( + .get::>>( HostResponse::VT_RESPONSE, None, ) @@ -3061,30 +3076,56 @@ pub mod host_response { } } - impl ::flatbuffers::Verifiable for HostResponse<'_> { + impl flatbuffers::Verifiable for HostResponse<'_> { #[inline] fn run_verifier( - v: &mut ::flatbuffers::Verifier, + v: &mut flatbuffers::Verifier, pos: usize, - ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_union::("response_type", Self::VT_RESPONSE_TYPE, "response", Self::VT_RESPONSE, true, |key, v, pos| { - match key { - HostResponseType::ContractResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("HostResponseType::ContractResponse", pos), - HostResponseType::DelegateResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("HostResponseType::DelegateResponse", pos), - HostResponseType::GenerateRandData => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("HostResponseType::GenerateRandData", pos), - HostResponseType::Ok => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("HostResponseType::Ok", pos), - HostResponseType::Error => v.verify_union_variant::<::flatbuffers::ForwardsUOffset>("HostResponseType::Error", pos), - _ => Ok(()), - } - })? - .finish(); + .visit_union::( + "response_type", + Self::VT_RESPONSE_TYPE, + "response", + Self::VT_RESPONSE, + true, + |key, v, pos| match key { + HostResponseType::ContractResponse => v + .verify_union_variant::>( + "HostResponseType::ContractResponse", + pos, + ), + HostResponseType::DelegateResponse => v + .verify_union_variant::>( + "HostResponseType::DelegateResponse", + pos, + ), + HostResponseType::GenerateRandData => v + .verify_union_variant::>( + "HostResponseType::GenerateRandData", + pos, + ), + HostResponseType::Ok => v + .verify_union_variant::>( + "HostResponseType::Ok", + pos, + ), + HostResponseType::Error => v + .verify_union_variant::>( + "HostResponseType::Error", + pos, + ), + _ => Ok(()), + }, + )? + .finish(); Ok(()) } } pub struct HostResponseArgs { pub response_type: HostResponseType, - pub response: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub response: Option>, } impl<'a> Default for HostResponseArgs { #[inline] @@ -3096,11 +3137,11 @@ pub mod host_response { } } - pub struct HostResponseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { - fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, + pub struct HostResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + start_: flatbuffers::WIPOffset, } - impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HostResponseBuilder<'a, 'b, A> { + impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> HostResponseBuilder<'a, 'b, A> { #[inline] pub fn add_response_type(&mut self, response_type: HostResponseType) { self.fbb_.push_slot::( @@ -3112,16 +3153,14 @@ pub mod host_response { #[inline] pub fn add_response( &mut self, - response: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + response: flatbuffers::WIPOffset, ) { - self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( - HostResponse::VT_RESPONSE, - response, - ); + self.fbb_ + .push_slot_always::>(HostResponse::VT_RESPONSE, response); } #[inline] pub fn new( - _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, ) -> HostResponseBuilder<'a, 'b, A> { let start = _fbb.start_table(); HostResponseBuilder { @@ -3130,15 +3169,15 @@ pub mod host_response { } } #[inline] - pub fn finish(self) -> ::flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); self.fbb_.required(o, HostResponse::VT_RESPONSE, "response"); - ::flatbuffers::WIPOffset::new(o.value()) + flatbuffers::WIPOffset::new(o.value()) } } - impl ::core::fmt::Debug for HostResponse<'_> { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + impl core::fmt::Debug for HostResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("HostResponse"); ds.field("response_type", &self.response_type()); match self.response_type() { @@ -3209,8 +3248,8 @@ pub mod host_response { /// `root_as_host_response_unchecked`. pub fn root_as_host_response( buf: &[u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root::(buf) + ) -> Result { + flatbuffers::root::(buf) } #[inline] /// Verifies that a buffer of bytes contains a size prefixed @@ -3221,8 +3260,8 @@ pub mod host_response { /// `size_prefixed_root_as_host_response_unchecked`. pub fn size_prefixed_root_as_host_response( buf: &[u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root::(buf) + ) -> Result { + flatbuffers::size_prefixed_root::(buf) } #[inline] /// Verifies, with the given options, that a buffer of bytes @@ -3232,10 +3271,10 @@ pub mod host_response { /// previous, unchecked, behavior use /// `root_as_host_response_unchecked`. pub fn root_as_host_response_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, + opts: &'o flatbuffers::VerifierOptions, buf: &'b [u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::root_with_opts::>(opts, buf) + ) -> Result, flatbuffers::InvalidFlatbuffer> { + flatbuffers::root_with_opts::>(opts, buf) } #[inline] /// Verifies, with the given verifier options, that a buffer of @@ -3245,37 +3284,37 @@ pub mod host_response { /// previous, unchecked, behavior use /// `root_as_host_response_unchecked`. pub fn size_prefixed_root_as_host_response_with_opts<'b, 'o>( - opts: &'o ::flatbuffers::VerifierOptions, + opts: &'o flatbuffers::VerifierOptions, buf: &'b [u8], - ) -> Result, ::flatbuffers::InvalidFlatbuffer> { - ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) + ) -> Result, flatbuffers::InvalidFlatbuffer> { + flatbuffers::size_prefixed_root_with_opts::>(opts, buf) } #[inline] /// Assumes, without verification, that a buffer of bytes contains a HostResponse and returns it. /// # Safety /// Callers must trust the given bytes do indeed contain a valid `HostResponse`. - pub unsafe fn root_as_host_response_unchecked(buf: &[u8]) -> HostResponse<'_> { - unsafe { ::flatbuffers::root_unchecked::(buf) } + pub unsafe fn root_as_host_response_unchecked(buf: &[u8]) -> HostResponse { + flatbuffers::root_unchecked::(buf) } #[inline] /// Assumes, without verification, that a buffer of bytes contains a size prefixed HostResponse and returns it. /// # Safety /// Callers must trust the given bytes do indeed contain a valid size prefixed `HostResponse`. - pub unsafe fn size_prefixed_root_as_host_response_unchecked(buf: &[u8]) -> HostResponse<'_> { - unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } + pub unsafe fn size_prefixed_root_as_host_response_unchecked(buf: &[u8]) -> HostResponse { + flatbuffers::size_prefixed_root_unchecked::(buf) } #[inline] - pub fn finish_host_response_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( - fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>, + pub fn finish_host_response_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>( + fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + root: flatbuffers::WIPOffset>, ) { fbb.finish(root, None); } #[inline] - pub fn finish_size_prefixed_host_response_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( - fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, - root: ::flatbuffers::WIPOffset>, + pub fn finish_size_prefixed_host_response_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>( + fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, + root: flatbuffers::WIPOffset>, ) { fbb.finish_size_prefixed(root, None); }