diff --git a/recapn-rpc/src/gen/capnp/rpc.capnp.rs b/recapn-rpc/src/gen/capnp/rpc.capnp.rs index 5997e69..242bf8a 100644 --- a/recapn-rpc/src/gen/capnp/rpc.capnp.rs +++ b/recapn-rpc/src/gen/capnp/rpc.capnp.rs @@ -105,7 +105,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const ABORT: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -117,7 +117,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const CALL: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -129,7 +129,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const RETURN: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -141,7 +141,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const FINISH: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -153,7 +153,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const RESOLVE: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -165,7 +165,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const RELEASE: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -177,7 +177,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const OBSOLETE_SAVE: _p::VariantDescriptor<_p::AnyPtr> = _p::VariantDescriptor::< @@ -189,7 +189,7 @@ impl Message { }, field: _p::Descriptor::<_p::AnyPtr> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const BOOTSTRAP: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -201,7 +201,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const OBSOLETE_DELETE: _p::VariantDescriptor<_p::AnyPtr> = _p::VariantDescriptor::< @@ -213,7 +213,7 @@ impl Message { }, field: _p::Descriptor::<_p::AnyPtr> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const PROVIDE: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -225,7 +225,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const ACCEPT: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -237,7 +237,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const JOIN: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -249,7 +249,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const DISEMBARGO: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -261,7 +261,7 @@ impl Message { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; } @@ -1084,7 +1084,7 @@ impl Bootstrap { _p::AnyPtr, > { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; } impl<'p, T: _p::rpc::Table + 'p> bootstrap::Reader<'p, T> { @@ -1240,7 +1240,7 @@ impl Call { _p::Struct, > { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const INTERFACE_ID: _p::Descriptor = _p::Descriptor:: { slot: 1u32, @@ -1254,7 +1254,7 @@ impl Call { _p::Struct, > { slot: 1u32, - default: None, + default: ::core::option::Option::None, }; const SEND_RESULTS_TO: _p::Descriptor<_p::Group> = (); const ALLOW_THIRD_PARTY_TAIL_CALL: _p::Descriptor = _p::Descriptor:: { @@ -1531,7 +1531,7 @@ pub mod call { type Builder<'a, T: _p::rpc::Table> = send_results_to::Builder<'a, T>; } impl _p::FieldGroup for SendResultsTo { - unsafe fn clear(s: &mut _p::StructBuilder<'_, T>) { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { s.set_field_unchecked(3usize, 0); <() as _p::field::FieldType>::clear(s, &SendResultsTo::CALLER.field); } @@ -1560,7 +1560,7 @@ pub mod call { }, field: _p::Descriptor::<_p::AnyPtr> { slot: 2u32, - default: None, + default: ::core::option::Option::None, }, }; } @@ -1850,7 +1850,7 @@ impl Return { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const EXCEPTION: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -1862,7 +1862,7 @@ impl Return { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const CANCELED: _p::VariantDescriptor<()> = _p::VariantDescriptor::<()> { @@ -1902,7 +1902,7 @@ impl Return { }, field: _p::Descriptor::<_p::AnyPtr> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; } @@ -2491,7 +2491,7 @@ impl Resolve { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const EXCEPTION: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< @@ -2503,7 +2503,7 @@ impl Resolve { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; } @@ -2890,7 +2890,7 @@ impl Disembargo { _p::Struct, > { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const CONTEXT: _p::Descriptor<_p::Group> = (); } @@ -3048,7 +3048,7 @@ pub mod disembargo { type Builder<'a, T: _p::rpc::Table> = context::Builder<'a, T>; } impl _p::FieldGroup for Context { - unsafe fn clear(s: &mut _p::StructBuilder<'_, T>) { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { s.set_field_unchecked(2usize, 0); ::clear(s, &Context::SENDER_LOOPBACK.field); } @@ -3387,11 +3387,11 @@ impl Provide { _p::Struct, > { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const RECIPIENT: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { slot: 1u32, - default: None, + default: ::core::option::Option::None, }; } impl<'p, T: _p::rpc::Table + 'p> provide::Reader<'p, T> { @@ -3561,7 +3561,7 @@ impl Accept { }; const PROVISION: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const EMBARGO: _p::Descriptor = _p::Descriptor:: { slot: 32u32, @@ -3721,11 +3721,11 @@ impl Join { _p::Struct, > { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const KEY_PART: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { slot: 1u32, - default: None, + default: ::core::option::Option::None, }; } impl<'p, T: _p::rpc::Table + 'p> join::Reader<'p, T> { @@ -3903,7 +3903,7 @@ impl MessageTarget { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; } @@ -4142,13 +4142,13 @@ impl _p::ty::Struct for Payload { impl Payload { const CONTENT: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const CAP_TABLE: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< _p::List<_p::Struct>, > { slot: 1u32, - default: None, + default: ::core::option::Option::None, }; } impl<'p, T: _p::rpc::Table + 'p> payload::Reader<'p, T> { @@ -4356,7 +4356,7 @@ impl CapDescriptor { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; const THIRD_PARTY_HOSTED: _p::VariantDescriptor< @@ -4368,7 +4368,7 @@ impl CapDescriptor { }, field: _p::Descriptor::<_p::Struct> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }, }; } @@ -4804,7 +4804,7 @@ impl PromisedAnswer { _p::List<_p::Struct>, > { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; } impl<'p, T: _p::rpc::Table + 'p> promised_answer::Reader<'p, T> { @@ -5201,7 +5201,7 @@ impl _p::ty::Struct for ThirdPartyCapDescriptor { impl ThirdPartyCapDescriptor { const ID: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const VINE_ID: _p::Descriptor = _p::Descriptor:: { slot: 0u32, @@ -5363,7 +5363,7 @@ impl _p::ty::Struct for Exception { impl Exception { const REASON: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const OBSOLETE_IS_CALLERS_FAULT: _p::Descriptor = _p::Descriptor:: { slot: 0u32, @@ -5381,7 +5381,7 @@ impl Exception { }; const TRACE: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { slot: 1u32, - default: None, + default: ::core::option::Option::None, }; } impl<'p, T: _p::rpc::Table + 'p> exception::Reader<'p, T> { diff --git a/recapn/src/field.rs b/recapn/src/field.rs index dfb48a3..b3aff97 100644 --- a/recapn/src/field.rs +++ b/recapn/src/field.rs @@ -50,7 +50,7 @@ use crate::ptr::{ }; use crate::rpc::{Capable, Empty, InsertableInto, Table}; use crate::ty::{self, EnumResult, ListValue, StructReader as _}; -use crate::{any, data, text, Error, ErrorKind, Family, NotInSchema, Result}; +use crate::{any, data, text, Error, Family, NotInSchema, Result}; mod internal { use super::*; @@ -1396,7 +1396,7 @@ where } #[inline] - pub fn get(&self) -> S::Reader<'b, T> { + pub fn get(&self) -> S::Reader<'p, T> { ty::StructReader::from_ptr(match self.raw_ptr().to_struct() { Ok(Some(ptr)) => ptr, _ => self.default_imbued_ptr(), @@ -1404,12 +1404,12 @@ where } #[inline] - pub fn get_option(&self) -> Option> { + pub fn get_option(&self) -> Option> { self.try_get_option().ok().flatten() } #[inline] - pub fn try_get(&self) -> Result> { + pub fn try_get(&self) -> Result> { Ok(ty::StructReader::from_ptr( match self.raw_ptr().to_struct() { Ok(Some(ptr)) => ptr, @@ -1420,7 +1420,7 @@ where } #[inline] - pub fn try_get_option(&self) -> Result>> { + pub fn try_get_option(&self) -> Result>> { match self.raw_ptr().to_struct() { Ok(Some(ptr)) => Ok(Some(ty::StructReader::from_ptr(ptr))), Ok(None) => Ok(None), @@ -1611,7 +1611,7 @@ impl PtrField { impl<'b, 'p: 'b, T: Table + 'p> PtrFieldReader<'b, 'p, T, text::Text> { #[inline] - pub fn get(&self) -> text::Reader<'b> { + pub fn get(&self) -> text::Reader<'p> { self.get_option().unwrap_or_else(|| self.default()) } @@ -1621,27 +1621,27 @@ impl<'b, 'p: 'b, T: Table + 'p> PtrFieldReader<'b, 'p, T, text::Text> { /// If the field is null or an error occurs while reading the pointer to the text itself, this /// returns the default value. #[inline] - pub fn as_str(&self) -> Result<&'b str, Utf8Error> { + pub fn as_str(&self) -> Result<&'p str, Utf8Error> { self.get().as_str() } #[inline] - pub fn get_option(&self) -> Option> { + pub fn get_option(&self) -> Option> { self.try_get_option().ok().flatten() } #[inline] - pub fn try_get(&self) -> Result> { + pub fn try_get(&self) -> Result> { self.try_get_option() .map(|op| op.unwrap_or_else(|| self.default())) } #[inline] - pub fn try_get_option(&self) -> Result>> { + pub fn try_get_option(&self) -> Result>> { match self.raw_ptr().to_blob() { Ok(Some(ptr)) => { let text = - text::Reader::new(ptr).ok_or(Error::from(ErrorKind::TextNotNulTerminated))?; + text::Reader::new(ptr).ok_or(Error::TextNotNulTerminated)?; Ok(Some(text)) } diff --git a/recapn/src/io.rs b/recapn/src/io.rs index 0cad25f..f80b7e8 100644 --- a/recapn/src/io.rs +++ b/recapn/src/io.rs @@ -66,8 +66,14 @@ impl From for ReadError { } } -#[cfg(feature = "std")] -impl std::error::Error for ReadError {} +impl core::error::Error for ReadError { + fn source(&self) -> Option<&(dyn core::error::Error + 'static)> { + match self { + ReadError::Table(table) => Some(table), + _ => None, + } + } +} /// A segment set that directly uses the stream table found in the message data without allocating. /// @@ -271,8 +277,8 @@ impl Display for StreamError { } } -impl std::error::Error for StreamError { - fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { +impl core::error::Error for StreamError { + fn source(&self) -> Option<&(dyn core::error::Error + 'static)> { match self { StreamError::Table(err) => Some(err), StreamError::SegmentTooLarge { .. } => None, diff --git a/recapn/src/io/packing.rs b/recapn/src/io/packing.rs index 5e548e6..63be2b7 100644 --- a/recapn/src/io/packing.rs +++ b/recapn/src/io/packing.rs @@ -260,8 +260,7 @@ impl fmt::Display for IncompleteError { } } -#[cfg(feature = "std")] -impl std::error::Error for IncompleteError {} +impl core::error::Error for IncompleteError {} #[derive(Clone, Copy, Debug)] enum WrittenBytes { diff --git a/recapn/src/io/stream.rs b/recapn/src/io/stream.rs index 502509f..9a43bc3 100644 --- a/recapn/src/io/stream.rs +++ b/recapn/src/io/stream.rs @@ -332,5 +332,4 @@ impl fmt::Display for TableReadError { } } -#[cfg(feature = "std")] -impl std::error::Error for TableReadError {} +impl core::error::Error for TableReadError {} diff --git a/recapn/src/lib.rs b/recapn/src/lib.rs index ae8f5a8..00628ca 100644 --- a/recapn/src/lib.rs +++ b/recapn/src/lib.rs @@ -87,7 +87,7 @@ pub trait IntoFamily { /// Errors that can occur while reading and writing in Cap'n Proto serialization format. #[non_exhaustive] #[derive(Debug)] -pub(crate) enum ErrorKind { +pub enum Error { /// The nesting limit has been exceeded, either because the message is too deeply-nested or /// it contains cycles. See [message::ReaderOptions]. NestingLimitExceeded, @@ -126,47 +126,42 @@ pub(crate) enum ErrorKind { OrphanFromDifferentMessage, } -#[derive(Debug)] -pub struct Error { - kind: ErrorKind, -} - impl Display for Error { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match &self.kind { - ErrorKind::NestingLimitExceeded => write!(f, "nesting limit exceeded"), - ErrorKind::PointerOutOfBounds => write!(f, "pointer out of bounds"), - ErrorKind::ReadLimitExceeded => write!(f, "read limit exceeded"), - ErrorKind::InlineCompositeOverrun => write!(f, "inline composite word count overrun"), - ErrorKind::UnsupportedInlineCompositeElementTag => { + match self { + Self::NestingLimitExceeded => write!(f, "nesting limit exceeded"), + Self::PointerOutOfBounds => write!(f, "pointer out of bounds"), + Self::ReadLimitExceeded => write!(f, "read limit exceeded"), + Self::InlineCompositeOverrun => write!(f, "inline composite word count overrun"), + Self::UnsupportedInlineCompositeElementTag => { write!(f, "unsupported inline composite element tag") } - ErrorKind::UnexpectedRead(read) => Display::fmt(read, f), - ErrorKind::IncompatibleUpgrade(upgrade) => Display::fmt(upgrade, f), - ErrorKind::CapabilityNotAllowed => write!(f, "capability not allowed in this context"), - ErrorKind::InvalidCapabilityPointer(index) => { + Self::UnexpectedRead(read) => Display::fmt(read, f), + Self::IncompatibleUpgrade(upgrade) => Display::fmt(upgrade, f), + Self::CapabilityNotAllowed => write!(f, "capability not allowed in this context"), + Self::InvalidCapabilityPointer(index) => { write!(f, "invalid capability pointer ({index})") } - ErrorKind::TextNotNulTerminated => write!(f, "text wasn't NUL terminated"), - ErrorKind::MissingSegment(id) => write!(f, "missing segment {id}"), - ErrorKind::WritingNotAllowed => write!(f, "attempted to write to read-only segment"), - ErrorKind::AllocTooLarge => write!(f, "allocation too large"), - ErrorKind::AllocFailed(size) => write!(f, "failed to allocate {size} words in message"), - ErrorKind::OrphanFromDifferentMessage => write!(f, "orphan from different message"), + Self::TextNotNulTerminated => write!(f, "text wasn't NUL terminated"), + Self::MissingSegment(id) => write!(f, "missing segment {id}"), + Self::WritingNotAllowed => write!(f, "attempted to write to read-only segment"), + Self::AllocTooLarge => write!(f, "allocation too large"), + Self::AllocFailed(size) => write!(f, "failed to allocate {size} words in message"), + Self::OrphanFromDifferentMessage => write!(f, "orphan from different message"), } } } -impl From for Error { - #[cold] - fn from(kind: ErrorKind) -> Self { - Error { kind } +impl core::error::Error for Error { + fn source(&self) -> Option<&(dyn core::error::Error + 'static)> { + match self { + Error::UnexpectedRead(read) => Some(read), + Error::IncompatibleUpgrade(upgrade) => Some(upgrade), + _ => None, + } } } -#[cfg(feature = "std")] -impl std::error::Error for Error {} - pub type Result = core::result::Result; /// A type representing a union or enum variant that doesn't exist in the Cap'n Proto schema. @@ -179,5 +174,4 @@ impl Display for NotInSchema { } } -#[cfg(feature = "std")] -impl std::error::Error for NotInSchema {} +impl core::error::Error for NotInSchema {} diff --git a/recapn/src/list.rs b/recapn/src/list.rs index 3eb8bd6..6a10c4c 100644 --- a/recapn/src/list.rs +++ b/recapn/src/list.rs @@ -19,7 +19,7 @@ use crate::ptr::{Data as FieldData, PtrElementSize, StructSize}; use crate::rpc::{self, Capable, InsertableInto, Table}; use crate::text::{self, Text}; use crate::ty::{self, EnumResult}; -use crate::{Error, ErrorKind, Family, IntoFamily, Result}; +use crate::{Error, Family, IntoFamily, Result}; use core::convert::TryFrom; use core::marker::PhantomData; @@ -1278,7 +1278,7 @@ where pub fn try_get_option(&self) -> Result>> { match self.ptr_reader().to_blob() { Ok(Some(b)) => text::Reader::new(b) - .ok_or_else(|| Error::from(ErrorKind::TextNotNulTerminated)) + .ok_or_else(|| Error::from(Error::TextNotNulTerminated)) .map(Some), Ok(None) => Ok(None), Err(err) => Err(err), @@ -1322,7 +1322,7 @@ where match self.into_ptr_builder().to_blob_mut() { Ok(blob) => match text::Builder::new(blob) { Some(text) => Ok(Some(text)), - None => Err(ErrorKind::TextNotNulTerminated.into()), + None => Err(Error::TextNotNulTerminated.into()), }, Err((None, _)) => Ok(None), Err((Some(err), _)) => Err(err), @@ -1756,6 +1756,17 @@ where } } +impl<'a, V, S, T, Item> ExactSizeIterator for Iter<'a, V, S, T> +where + V: for<'b> ListAccessable<&'b Reader<'a, V, T>>, + S: for<'b> IterStrategy, Item = Item>, + T: Table, +{ + fn len(&self) -> usize { + self.range.len() + } +} + impl<'a, V, T> Reader<'a, V, T> where T: Table, diff --git a/recapn/src/ptr.rs b/recapn/src/ptr.rs index 3080742..09c6934 100644 --- a/recapn/src/ptr.rs +++ b/recapn/src/ptr.rs @@ -15,7 +15,7 @@ use crate::rpc::{ Table, }; use crate::ty; -use crate::{Error, ErrorKind, Result}; +use crate::{Error, Result}; use core::convert::Infallible; use core::fmt::Debug; use core::marker::PhantomData; @@ -436,7 +436,7 @@ impl Parts { #[inline] fn fail_upgrade(from: PtrElementSize, to: PtrElementSize) -> Error { - ErrorKind::IncompatibleUpgrade(IncompatibleUpgrade { from, to }).into() + Error::IncompatibleUpgrade(IncompatibleUpgrade { from, to }) } #[derive(Clone, Copy)] @@ -455,7 +455,7 @@ impl WirePtr { /// Creates a failed read error based on the expected data we intended to read #[cold] fn fail_read(&self, expected: Option) -> Error { - ErrorKind::UnexpectedRead(FailedRead { + Error::UnexpectedRead(FailedRead { expected, actual: { if self.is_null() { @@ -1328,7 +1328,7 @@ impl From for WirePtr { } #[derive(Debug)] -pub(crate) enum ExpectedRead { +pub enum ExpectedRead { Struct, List, Far, @@ -1336,7 +1336,7 @@ pub(crate) enum ExpectedRead { } #[derive(Debug)] -pub(crate) enum ActualRead { +pub enum ActualRead { Null, Struct, List, @@ -1345,7 +1345,7 @@ pub(crate) enum ActualRead { } #[derive(Debug)] -pub(crate) struct FailedRead { +pub struct FailedRead { /// The thing we expected to read from the pointer. pub expected: Option, /// The actual pointer value. @@ -1381,8 +1381,7 @@ impl fmt::Display for FailedRead { } } -#[cfg(feature = "std")] -impl std::error::Error for FailedRead {} +impl core::error::Error for FailedRead {} /// An error returned when attempting to perform an incompatible upgrade to another list type. #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1415,8 +1414,7 @@ impl fmt::Display for IncompatibleUpgrade { } } -#[cfg(feature = "std")] -impl std::error::Error for IncompatibleUpgrade {} +impl core::error::Error for IncompatibleUpgrade {} /// Describes the location of an object in a Cap'n Proto message. This can be used to create /// pointers directly into a message without needing to navigate through the message tree. @@ -1666,15 +1664,15 @@ impl<'a> ObjectReader<'a> { .segment .as_ref() .and_then(|r| r.segment(segment)) - .ok_or(ErrorKind::MissingSegment(segment))?; + .ok_or(Error::MissingSegment(segment))?; let ptr = reader .try_get_section_offset(offset, len) - .ok_or(ErrorKind::PointerOutOfBounds)?; + .ok_or(Error::PointerOutOfBounds)?; if let Some(limiter) = self.limiter { if !limiter.try_read(len.get().into()) { - return Err(ErrorKind::ReadLimitExceeded.into()); + return Err(Error::ReadLimitExceeded.into()); } } @@ -1693,7 +1691,7 @@ impl<'a> ObjectReader<'a> { let new_ptr = if let Some(segment) = &self.segment { segment .try_get_section(start, len) - .ok_or(ErrorKind::PointerOutOfBounds)? + .ok_or(Error::PointerOutOfBounds)? } else { // SAFETY: the pointer is unchecked, which is unsafe to make anyway, so whoever made // the pointer originally upholds safety here @@ -1702,7 +1700,7 @@ impl<'a> ObjectReader<'a> { if let Some(limiter) = self.limiter { if !limiter.try_read(len.get().into()) { - return Err(ErrorKind::ReadLimitExceeded.into()); + return Err(Error::ReadLimitExceeded.into()); } } @@ -1823,7 +1821,7 @@ impl<'a> ObjectReader<'a> { let word_count = list_ptr.element_count().get(); // add one for the tag pointer, because this could overflow the size of a segment, // we just assume on overflow the bounds check fails and is out of bounds. - let len = ObjectLen::new(word_count + 1).ok_or(ErrorKind::PointerOutOfBounds)?; + let len = ObjectLen::new(word_count + 1).ok_or(Error::PointerOutOfBounds)?; let tag_ptr = match location { Location::Near { origin } | Location::Far { origin } => { @@ -1837,7 +1835,7 @@ impl<'a> ObjectReader<'a> { let tag = tag_ptr .as_wire_ptr() .struct_ptr() - .ok_or(ErrorKind::UnsupportedInlineCompositeElementTag)?; + .ok_or(Error::UnsupportedInlineCompositeElementTag)?; // move past the tag pointer to get the start of the list let first = unsafe { tag_ptr.offset(1.into()).as_ref_unchecked() }; @@ -1856,14 +1854,14 @@ impl<'a> ObjectReader<'a> { if u64::from(element_count.get()) * u64::from(words_per_element) > word_count.into() { // Make sure the tag reports a struct size that matches the reported word count - return Err(ErrorKind::InlineCompositeOverrun.into()); + return Err(Error::InlineCompositeOverrun.into()); } if words_per_element == 0 { // watch out for zero-sized structs, which can claim to be arbitrarily // large without having sent actual data. if !self.try_amplified_read(u64::from(element_count.get())) { - return Err(ErrorKind::ReadLimitExceeded.into()); + return Err(Error::ReadLimitExceeded.into()); } } @@ -1883,9 +1881,9 @@ impl<'a> ObjectReader<'a> { let element_count = list_ptr.element_count(); if element_size == ElementSize::Void - && self.try_amplified_read(element_count.get() as u64) + && !self.try_amplified_read(element_count.get() as u64) { - return Err(ErrorKind::ReadLimitExceeded.into()); + return Err(Error::ReadLimitExceeded.into()); } let element_bits = element_size.bits(); @@ -2011,7 +2009,7 @@ fn target_size(reader: &ObjectReader<'_>, ptr: SegmentRef<'_>, nesting_limit: u3 TypedContent::Struct(content) => { let nesting_limit = nesting_limit .checked_sub(1) - .ok_or_else(|| Error::from(ErrorKind::NestingLimitExceeded))?; + .ok_or_else(|| Error::from(Error::NestingLimitExceeded))?; total_struct_size(&reader, content, nesting_limit)? } @@ -2028,7 +2026,7 @@ fn target_size(reader: &ObjectReader<'_>, ptr: SegmentRef<'_>, nesting_limit: u3 ElementSize::InlineComposite(size) => { let nesting_limit = nesting_limit .checked_sub(1) - .ok_or_else(|| Error::from(ErrorKind::NestingLimitExceeded))?; + .ok_or_else(|| Error::from(Error::NestingLimitExceeded))?; let mut composites = total_inline_composites_targets_size( &reader, @@ -2043,7 +2041,7 @@ fn target_size(reader: &ObjectReader<'_>, ptr: SegmentRef<'_>, nesting_limit: u3 ElementSize::Pointer => { let nesting_limit = nesting_limit .checked_sub(1) - .ok_or_else(|| Error::from(ErrorKind::NestingLimitExceeded))?; + .ok_or_else(|| Error::from(Error::NestingLimitExceeded))?; total_ptrs_size(&reader, start, element_count, nesting_limit)? } @@ -2201,7 +2199,7 @@ impl<'a, T: Table> PtrReader<'a, T> { let nesting_limit = self .nesting_limit .checked_sub(1) - .ok_or(ErrorKind::NestingLimitExceeded)?; + .ok_or(Error::NestingLimitExceeded)?; target_size(&self.reader, self.ptr, nesting_limit) } @@ -2244,7 +2242,7 @@ impl<'a, T: Table> PtrReader<'a, T> { let nesting_limit = self .nesting_limit .checked_sub(1) - .ok_or(ErrorKind::NestingLimitExceeded)?; + .ok_or(Error::NestingLimitExceeded)?; let mut reader = self.reader.clone(); let content = reader.try_read_struct(self.ptr)?; @@ -2271,7 +2269,7 @@ impl<'a, T: Table> PtrReader<'a, T> { } let Some(nesting_limit) = self.nesting_limit.checked_sub(1) else { - return Err(ErrorKind::NestingLimitExceeded.into()); + return Err(Error::NestingLimitExceeded.into()); }; let mut reader = self.reader.clone(); @@ -2377,7 +2375,7 @@ impl PtrReader<'_, T> { Ok(Some(i)) => self .table .extract_cap(i) - .ok_or_else(|| ErrorKind::InvalidCapabilityPointer(i).into()) + .ok_or_else(|| Error::InvalidCapabilityPointer(i).into()) .map(Some), Ok(None) => Ok(None), Err(err) => Err(err), @@ -2647,6 +2645,22 @@ impl<'a, T: Table> StructReader<'a, T> { self.ptr_field_option(index) .unwrap_or_else(|| PtrReader::null().imbue(self.table.clone())) } + + #[inline] + pub unsafe fn field<'b, V: field::FieldType>( + &'b self, + descriptor: &'static V::Descriptor, + ) -> V::Accessor<&'b Self> { + unsafe { V::accessor(self, descriptor) } + } + + #[inline] + pub unsafe fn variant<'b, V: field::FieldType>( + &'b self, + descriptor: &'static field::VariantDescriptor, + ) -> V::VariantAccessor<&'b Self> { + unsafe { V::variant(self, descriptor) } + } } impl<'a, T: Table> Clone for StructReader<'a, T> { @@ -3378,7 +3392,7 @@ impl<'a> ObjectBuilder<'a> { let len_with_pad = AllocLen::new(size.total() + 1).unwrap(); let (pad, object_segment) = self .alloc_in_arena(len_with_pad) - .ok_or(ErrorKind::AllocFailed(len_with_pad))?; + .ok_or(Error::AllocFailed(len_with_pad))?; let start = unsafe { pad.offset(1u16.into()).as_ref_unchecked() }; // our pad is the actual pointer to the content @@ -3402,7 +3416,7 @@ impl<'a> ObjectBuilder<'a> { return Ok((object, self.clone())); }; - let (start, segment) = self.alloc(len).ok_or(ErrorKind::AllocFailed(len))?; + let (start, segment) = self.alloc(len).ok_or(Error::AllocFailed(len))?; Ok(( OrphanObject::Struct { location: start, @@ -3424,7 +3438,7 @@ impl<'a> ObjectBuilder<'a> { Location::DoubleFar { segment, offset } => { match builder.build_object_in(segment, offset) { Some(b) => b, - None => return Err(ErrorKind::WritingNotAllowed.into()), + None => return Err(Error::WritingNotAllowed.into()), } } }; @@ -3467,7 +3481,7 @@ impl<'a> ObjectBuilder<'a> { self.clone(), )); } - let len = AllocLen::new(total_size).ok_or(ErrorKind::AllocTooLarge)?; + let len = AllocLen::new(total_size).ok_or(Error::AllocTooLarge)?; let list_ptr_element_count = if is_struct_list { SegmentOffset::new(size).unwrap() @@ -3490,7 +3504,7 @@ impl<'a> ObjectBuilder<'a> { let (pad, segment) = self .alloc_in_arena(len_with_landing_pad) - .ok_or(ErrorKind::AllocFailed(len_with_landing_pad))?; + .ok_or(Error::AllocFailed(len_with_landing_pad))?; let start = unsafe { pad.offset(1u16.into()).as_ref_unchecked() }; let offset_to_pad = segment.offset_from_start(pad.into()); @@ -3536,12 +3550,12 @@ impl<'a> ObjectBuilder<'a> { // segment, which is just a waste of space. let Some((pad, tag, pad_builder)) = self.alloc_double_far_landing_pad() else { - return Err(ErrorKind::AllocFailed(LANDING_PAD_LEN).into()); + return Err(Error::AllocFailed(LANDING_PAD_LEN).into()); }; let (start, list_segment) = self .alloc_in_arena(AllocLen::MAX) - .ok_or(ErrorKind::AllocFailed(AllocLen::MAX))?; + .ok_or(Error::AllocFailed(AllocLen::MAX))?; let offset_to_pad = pad_builder.offset_from_start(pad.into()); self.set_ptr(ptr, FarPtr::new(pad_builder.id(), offset_to_pad, true)); @@ -3581,8 +3595,8 @@ impl<'a> ObjectBuilder<'a> { return Ok((object, self.clone())); } - let len = AllocLen::new(total_size).ok_or(ErrorKind::AllocTooLarge)?; - let (alloc_start, segment) = self.alloc(len).ok_or(ErrorKind::AllocFailed(len))?; + let len = AllocLen::new(total_size).ok_or(Error::AllocTooLarge)?; + let (alloc_start, segment) = self.alloc(len).ok_or(Error::AllocFailed(len))?; if let ElementSize::InlineComposite(size) = element_size { segment.set_ptr( alloc_start, @@ -3610,7 +3624,7 @@ impl<'a> ObjectBuilder<'a> { Location::DoubleFar { segment, offset } => { match builder.build_object_in(segment, offset) { Some(b) => b, - None => return Err(ErrorKind::WritingNotAllowed.into()), + None => return Err(Error::WritingNotAllowed.into()), } } }; @@ -4064,7 +4078,7 @@ impl<'a, T: Table> PtrBuilder<'a, T> { from: existing_size.into(), to: expected.into(), }; - return Err(ErrorKind::IncompatibleUpgrade(failed_upgrade).into()); + return Err(Error::IncompatibleUpgrade(failed_upgrade).into()); } }, None => None, @@ -4183,7 +4197,7 @@ impl<'a, T: Table> PtrBuilder<'a, T> { let size = match size.builder_size(value) { Ok(size) => size, Err(err) => { - return match err_handler.handle_err(ErrorKind::IncompatibleUpgrade(err).into()) { + return match err_handler.handle_err(Error::IncompatibleUpgrade(err).into()) { ControlFlow::Continue(WriteNull) => Ok(()), ControlFlow::Break(err) => Err(err), } @@ -4250,7 +4264,7 @@ impl<'a, T: Table> PtrBuilder<'a, T> { ) = self.builder.build_list(self.ptr)?; if element_size != ElementSize::Byte { - return Err(ErrorKind::IncompatibleUpgrade(IncompatibleUpgrade { + return Err(Error::IncompatibleUpgrade(IncompatibleUpgrade { from: element_size.into(), to: PtrElementSize::Byte, }) @@ -4387,7 +4401,7 @@ impl<'a, T: Table> PtrBuilder<'a, T> { orphan: OrphanBuilder<'b, T>, ) -> BuildResult<(), OrphanBuilder<'b, T>, Error> { if !orphan.builder.is_same_message(&self.builder) { - return Err((ErrorKind::OrphanFromDifferentMessage.into(), orphan)); + return Err((Error::OrphanFromDifferentMessage.into(), orphan)); } self.clear(); @@ -4456,7 +4470,7 @@ impl<'a, T: Table> PtrBuilder<'a, T> { self.builder .set_ptr(self.ptr, FarPtr::new(pad_builder.id(), pad_offset, true)); } else { - return Err((ErrorKind::AllocFailed(LANDING_PAD_LEN).into(), orphan)); + return Err((Error::AllocFailed(LANDING_PAD_LEN).into(), orphan)); } Ok(()) @@ -4909,6 +4923,43 @@ impl<'a, T: Table> StructBuilder<'a, T> { } } + #[inline] + pub unsafe fn field<'b, V: field::FieldType>( + &'b mut self, + descriptor: &'static V::Descriptor, + ) -> V::Accessor<&'b mut Self> { + unsafe { V::accessor(self, descriptor) } + } + + #[inline] + pub unsafe fn variant<'b, V: field::FieldType>( + &'b mut self, + descriptor: &'static field::VariantDescriptor, + ) -> V::VariantAccessor<&'b mut Self> { + unsafe { V::variant(self, descriptor) } + } + + #[inline] + pub unsafe fn into_field( + self, + descriptor: &'static V::Descriptor, + ) -> V::Accessor { + unsafe { V::accessor(self, descriptor) } + } + + #[inline] + pub unsafe fn into_variant<'b, V: field::FieldType>( + self, + descriptor: &'static field::VariantDescriptor, + ) -> V::VariantAccessor { + unsafe { V::variant(self, descriptor) } + } + + #[inline] + pub unsafe fn clear_field(&mut self, descriptor: &'static V::Descriptor) { + unsafe { V::clear(self, descriptor) } + } + /// Mostly behaves like you'd expect a copy to behave, but with a caveat originating from /// the fact that the struct cannot be resized in place. /// @@ -5923,7 +5974,7 @@ fn transfer_ptr( new_dst_ptr } else { - return Err(ErrorKind::AllocFailed(LANDING_PAD_LEN).into()); + return Err(Error::AllocFailed(LANDING_PAD_LEN).into()); } } WireKind::Far | WireKind::Other => *ptr, @@ -6118,7 +6169,7 @@ where Err(err) => self.handle_err(err), }, TypedContent::Capability(_) if self.canonical => { - self.handle_err(Error::from(ErrorKind::CapabilityNotAllowed)) + self.handle_err(Error::from(Error::CapabilityNotAllowed)) } TypedContent::Capability(cap) => match U::copy(self.src_table, cap, self.dst_table) { Ok(Some(new_idx)) => { diff --git a/recapn/src/rpc.rs b/recapn/src/rpc.rs index bd81d27..1bf5e4e 100644 --- a/recapn/src/rpc.rs +++ b/recapn/src/rpc.rs @@ -12,7 +12,7 @@ pub(crate) mod internal { use super::{ CapSystem, CapTable, CapTableBuilder, CapTableReader, CapTranslator, Empty, Table, }; - use crate::{ErrorKind, Result}; + use crate::{Error, Result}; use core::convert::Infallible; pub trait CapPtrReader: Clone { @@ -36,7 +36,7 @@ pub(crate) mod internal { impl CapPtrBuilder for Empty { fn clear_cap(&self, _: u32) -> Result<()> { - Err(ErrorKind::CapabilityNotAllowed.into()) + Err(Error::CapabilityNotAllowed) } fn as_reader(&self) -> Self { Self @@ -46,7 +46,7 @@ pub(crate) mod internal { impl InsertableInto for Empty { #[inline] fn copy(_: &Self::Reader, _: u32, _: &T::Builder) -> Result> { - Err(ErrorKind::CapabilityNotAllowed.into()) + Err(Error::CapabilityNotAllowed) } } @@ -56,7 +56,7 @@ pub(crate) mod internal { impl InsertableInto for C { #[inline] fn copy(_: &Self::Reader, _: u32, _: &Empty) -> Result> { - Err(ErrorKind::CapabilityNotAllowed.into()) + Err(Error::CapabilityNotAllowed) } } @@ -74,7 +74,7 @@ pub(crate) mod internal { ) -> Result> { let cap = reader .extract_cap(index) - .ok_or(ErrorKind::InvalidCapabilityPointer(index))?; + .ok_or(Error::InvalidCapabilityPointer(index))?; let new_index = CapTranslator::inject_cap(builder, cap); Ok(new_index) } diff --git a/recapn/src/text.rs b/recapn/src/text.rs index f930b1c..e13390a 100644 --- a/recapn/src/text.rs +++ b/recapn/src/text.rs @@ -1,5 +1,6 @@ //! UTF-8 encoded data with a null terminator +use core::fmt; use core::ptr::NonNull; use core::slice; use core::str::Utf8Error; @@ -119,6 +120,12 @@ impl<'a> Reader<'a> { } } +impl fmt::Debug for Reader<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.as_bytes_with_nul().fmt(f) + } +} + impl<'a> From> for ptr::Reader<'a> { fn from(value: Reader<'a>) -> Self { value.0 diff --git a/recapn/src/ty.rs b/recapn/src/ty.rs index 71f6cf3..70f7b65 100644 --- a/recapn/src/ty.rs +++ b/recapn/src/ty.rs @@ -1,8 +1,11 @@ //! Types and traits implemented by foreign generated user types like enums and structs. use core::convert::TryFrom; +use core::marker::PhantomData; +use core::ptr::NonNull; -use crate::any; +use crate::alloc::Word; +use crate::any::{self, PtrReader}; use crate::field; use crate::internal::Sealed; use crate::list::{self, ElementSize, List}; @@ -219,6 +222,51 @@ impl DynListValue for T { const PTR_ELEMENT_SIZE: ptr::PtrElementSize = T::ELEMENT_SIZE.as_ptr_size(); } +/// A constant of some Cap'n Proto value. +pub struct ConstPtr { + t: PhantomData T>, + inner: Option>, +} + +impl ConstPtr { + /// Create a new constant value backed by the given static array of words. + /// + /// This is normally used by the code generator to create constant pointer values. + /// + /// # Safety + /// + /// This must be a valid Cap'n Proto message contained within a single segment. The message is + /// not checked for validity and as such an invalid message can cause Undefined Behavior. + pub const unsafe fn new(w: &'static [Word]) -> Self { + Self { t: PhantomData, inner: Some(NonNull::new_unchecked(w.as_ptr().cast_mut())) } + } + + /// Create a constant value to a null pointer. + /// + /// This will return the value's default when you `get()` its value. + pub const fn null() -> Self { + Self { t: PhantomData, inner: None } + } + + /// Get the value of the constant as an untyped pointer. + #[inline] + pub fn root(&self) -> PtrReader<'static> { + let ptr = match self.inner { + Some(ptr) => unsafe { ptr::PtrReader::new_unchecked(ptr) }, + None => ptr::PtrReader::null(), + }; + any::PtrReader::from(ptr) + } +} + +impl>> ConstPtr { + /// Get the value of the constant. + #[inline] + pub fn get(&self) -> T::Output { + self.root().read_as::() + } +} + pub type Void = (); pub type Bool = bool; diff --git a/recapnc/Cargo.toml b/recapnc/Cargo.toml index de48721..18847a7 100644 --- a/recapnc/Cargo.toml +++ b/recapnc/Cargo.toml @@ -10,7 +10,7 @@ recapn = { path = "../recapn", features = [] } syn = { version = "2.0", features = ["full"] } quote = "1.0" proc-macro2 = "1.0" -anyhow = "1.0" +thiserror = "1.0" unicode-ident = "1.0" heck = "0.4" prettyplease = "0.2" diff --git a/recapnc/src/bin/capnpc-rust.rs b/recapnc/src/bin/capnpc-rust.rs index b40aec2..63e6f6b 100644 --- a/recapnc/src/bin/capnpc-rust.rs +++ b/recapnc/src/bin/capnpc-rust.rs @@ -1,4 +1,4 @@ -fn main() -> anyhow::Result<()> { +fn main() -> recapnc::Result<()> { let mut stdin = std::io::stdin().lock(); recapnc::generate_from_request_stream(&mut stdin, ".") } diff --git a/recapnc/src/generator.rs b/recapnc/src/generator.rs index 3b8397e..d059768 100644 --- a/recapnc/src/generator.rs +++ b/recapnc/src/generator.rs @@ -1,35 +1,35 @@ -use std::collections::{HashMap, HashSet}; +use std::collections::hash_map::Entry; +use std::collections::{BTreeSet, HashMap}; +use std::fmt; use std::ptr::NonNull; +use std::str::Utf8Error; -use anyhow::{ensure, Context, Result}; use heck::{AsPascalCase, AsShoutySnakeCase, AsSnakeCase}; use proc_macro2::TokenStream; use quote::quote; use recapn::alloc::{self, AllocLen, Segment, SegmentOffset, Word}; use recapn::any::{AnyList, AnyStruct}; use recapn::ptr::{ElementSize, StructSize, UnwrapErrors}; -use recapn::{any, ReaderOf}; +use recapn::{any, data, text, ReaderOf}; use syn::punctuated::Punctuated; use syn::PathSegment; +use thiserror::Error; -use crate::gen::capnp_schema_capnp as schema; +use crate::Result; use crate::quotes::{ FieldDescriptor, GeneratedConst, GeneratedEnum, GeneratedField, GeneratedFile, GeneratedItem, GeneratedRootFile, GeneratedStruct, GeneratedVariant, GeneratedWhich, }; -use schema::node::{Const, Struct, Which as NodeKind}; -use schema::r#type::{ - any_pointer::unconstrained::Which as ConstraintKind, any_pointer::Which as AnyPtrKind, - Which as TypeKind, +use crate::schema::{ + schema_capnp, AnnotationSchema, ConstSchema, EnumSchema, FieldType, FileSchema, Id, + InterfaceSchema, NamedNestedItem, NestedItem, Schema, SchemaError, SchemaLoader, StructSchema, + Type, TypeKind }; -use schema::{CodeGeneratorRequest, Field, Node, Type, Value}; pub mod ident; use self::ident::{IdentifierSet, Scope, ScopedIdentifierSet}; -const NO_DISCRIMINANT: u16 = 0xffff; - #[derive(Clone, Debug, Hash)] struct ModScope { pub id: u64, @@ -134,260 +134,369 @@ struct ConstInfo { pub scope: TypeScope, } +#[derive(Debug)] +struct InterfaceInfo {} + +#[derive(Debug)] +struct AnnotationInfo {} + #[derive(Debug)] enum NodeInfo { File(FileInfo), Struct(StructInfo), Enum(EnumInfo), Const(ConstInfo), + Interface(InterfaceInfo), + Annotation(AnnotationInfo), } -struct NodeContext<'a> { - pub node: ReaderOf<'a, Node>, - pub info: Option, +impl NodeInfo { + pub fn unwrap_file(&self) -> &FileInfo { + if let Self::File(info) = self { + info + } else { + panic!("expected file node info") + } + } + + pub fn unwrap_struct(&self) -> &StructInfo { + if let Self::Struct(info) = self { + info + } else { + panic!("expected struct node info") + } + } + + pub fn unwrap_enum(&self) -> &EnumInfo { + if let Self::Enum(info) = self { + info + } else { + panic!("expected enum node info") + } + } + + pub fn unwrap_const(&self) -> &ConstInfo { + if let Self::Const(info) = self { + info + } else { + panic!("expected const node info") + } + } } -enum FieldKind { - Data, - Pointer, +type NodeInfoMap = HashMap; + +#[derive(Debug)] +pub enum NameContext { + Node(Id), + Field { + type_id: Id, + index: u32, + }, + Enumerant { + type_id: Id, + index: u32, + }, } -impl FieldKind { - pub fn from_proto(r: &ReaderOf) -> Result { - use TypeKind as Kind; - Ok(match r.which()? { - Kind::Void(_) - | Kind::Bool(_) - | Kind::Uint8(_) - | Kind::Uint16(_) - | Kind::Uint32(_) - | Kind::Uint64(_) - | Kind::Int8(_) - | Kind::Int16(_) - | Kind::Int32(_) - | Kind::Int64(_) - | Kind::Float32(_) - | Kind::Float64(_) - | Kind::Enum(_) => Self::Data, - Kind::Text(_) - | Kind::Data(_) - | Kind::List(_) - | Kind::Struct(_) - | Kind::Interface(_) - | Kind::AnyPointer(_) => Self::Pointer, - }) +impl fmt::Display for NameContext { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::Node(id) => write!(f, "node {:0<#16x}", id), + Self::Field { type_id, index } => + write!(f, "field @{} in struct @{:0<#16x}", index, type_id), + Self::Enumerant { type_id, index } => + write!(f, "enumerant @{} in enum @{:0<#16x}", index, type_id), + } } } -pub struct GeneratorContext<'a> { - nodes: HashMap>, +#[derive(Debug, Error)] +pub enum GeneratorError { + #[error("name for {context} is not valid UTF8: {error}")] + InvalidName { + context: NameContext, + error: Utf8Error, + }, + #[error("item has empty name")] + EmptyName, } -impl<'a> GeneratorContext<'a> { - pub fn new(request: &ReaderOf<'a, CodeGeneratorRequest>) -> Result { - let mut identifiers = ScopedIdentifierSet::new(); - let mut nodes = request - .nodes() - .into_iter() - .map(|node| (node.id(), NodeContext { node, info: None })) - .collect(); +fn validate_file( + schema: &FileSchema<'_>, + nodes: &mut NodeInfoMap, + identifiers: &mut ScopedIdentifierSet, +) -> Result<()> { + let id = schema.node.id(); + let Entry::Vacant(entry) = nodes.entry(id) else { + return Err(SchemaError::DuplicateNode(id))? + }; - let files = request - .nodes() - .into_iter() - .filter(|node| node.file().is_set()); - for node in files { - Self::validate_file_node(&mut nodes, &mut identifiers, &node) - .with_context(|| format!("Failed to validate file node {}", node.id()))?; - } + let path = schema.node + .display_name() + .get() + .as_str() + .map_err(|error| GeneratorError::InvalidName { + context: NameContext::Node(id), + error, + })?; + let mod_ident = identifiers.make_unique(None, &path)?; + let file_path = format!("{path}.rs"); + entry.insert(NodeInfo::File(FileInfo { + mod_ident: mod_ident.clone(), + path: file_path, + })); + + let mut scope = Scope::file(ModScope { + id, + mod_ident, + }); + + for nested in schema.nested_items() { + validate_item(nested?, nodes, identifiers, &mut scope)?; + } - Ok(Self { nodes }) + Ok(()) +} + +fn validate_item( + node: NamedNestedItem<'_>, + nodes: &mut NodeInfoMap, + identifiers: &mut ScopedIdentifierSet, + scope: &mut TypeScope, +) -> Result<()> { + let name = node.name.as_str().map_err(|error| GeneratorError::InvalidName { + context: NameContext::Node(node.id), error + })?; + match &node.item { + NestedItem::Struct(schema) => validate_struct(schema, name, nodes, identifiers, scope), + NestedItem::Enum(schema) => validate_enum(schema, name, nodes, identifiers, scope), + NestedItem::Interface(schema) => validate_interface(schema, name, nodes, identifiers, scope), + NestedItem::Const(schema) => validate_const(schema, name, nodes, identifiers, scope), + NestedItem::Annotation(schema) => validate_annotation(schema, name, nodes, identifiers, scope), } +} + +fn validate_struct( + schema: &StructSchema<'_>, + name: &str, + nodes: &mut NodeInfoMap, + identifiers: &mut ScopedIdentifierSet, + scope: &mut TypeScope, +) -> Result<()> { + let id = schema.node.id(); + let Entry::Vacant(entry) = nodes.entry(id) else { + return Err(SchemaError::DuplicateNode(id))? + }; + + let type_ident = identifiers.make_unique(Some(scope.clone()), AsPascalCase(name))?; + let mod_ident = identifiers.make_unique(Some(scope.clone()), AsSnakeCase(name))?; + + let node_info = StructInfo { + type_info: TypeInfo { + type_ident, + scope: scope.clone(), + }, + mod_ident: mod_ident.clone(), + }; - fn validate_file_node( - nodes: &mut HashMap>, - identifiers: &mut ScopedIdentifierSet, - file: &ReaderOf<'a, Node>, - ) -> Result<()> { - let node = nodes - .get_mut(&file.id()) - .with_context(|| format!("missing node {}", file.id()))?; - - ensure!(node.info.is_none(), "node already has associated info"); - - let path = file - .display_name() - .try_get()? - .as_bytes() - .escape_ascii() - .to_string(); - let mod_ident = identifiers.make_unique(None, &path)?; - let file_path = format!("{path}.rs"); - node.info = Some(NodeInfo::File(FileInfo { - mod_ident: mod_ident.clone(), - path: file_path, - })); - - let mut scope = Scope::file(ModScope { - id: file.id(), - mod_ident, - }); - - Self::validate_scope(file, nodes, identifiers, &mut scope)?; - - Ok(()) + entry.insert(NodeInfo::Struct(node_info)); + + scope.push(ModScope { id, mod_ident }); + + if schema.info.discriminant_count() != 0 { + // Insert Which into the identifier set so if any conflicts appear they'll + // be made properly unique + let _ = identifiers.make_unique(Some(scope.clone()), "Which")?; } - fn validate_scope( - node: &ReaderOf<'a, Node>, - nodes: &mut HashMap>, - identifiers: &mut ScopedIdentifierSet, - scope: &mut TypeScope, - ) -> Result<()> { - for nested in node.nested_nodes() { - let name = nested.name().as_str()?; - Self::validate_node(nested.id(), name, nodes, identifiers, scope)?; - } + for nested in schema.nested_items() { + validate_item(nested?, nodes, identifiers, scope)?; + } - // For some reason, groups are not considered nested nodes of structs. So we - // have to iter over all fields and find all the groups contained - if let Some(struct_type) = node.r#struct().get() { - let groups = struct_type - .fields() - .into_iter() - .filter_map(|f| f.group().get().map(|group| (f, group.type_id()))); - for (field, group_id) in groups { - let name = field.name().as_str()?; - Self::validate_node(group_id, name, nodes, identifiers, scope)?; - } + // For some reason, groups are not considered nested nodes of structs. So we + // have to iter over all fields and find all the groups contained + for (idx, field) in schema.fields().enumerate() { + if let FieldType::Group(schema) = field.field_type()? { + let name = field.name().as_str().map_err(|error| GeneratorError::InvalidName { + context: NameContext::Field { type_id: id, index: idx as u32 }, error + })?; + validate_struct(&schema, name, nodes, identifiers, scope)?; } - Ok(()) } - fn validate_node( - node: u64, - name: &str, - nodes: &mut HashMap>, - identifiers: &mut ScopedIdentifierSet, - scope: &mut TypeScope, - ) -> Result<()> { - let Some(NodeContext { info, ref node }) = nodes.get_mut(&node) else { - return Ok(()); - }; + scope.pop(); + Ok(()) +} - ensure!(info.is_none(), "node already has associated info"); +fn validate_enum( + schema: &EnumSchema<'_>, + name: &str, + nodes: &mut NodeInfoMap, + identifiers: &mut ScopedIdentifierSet, + scope: &mut TypeScope, +) -> Result<()> { + let id = schema.node.id(); + let Entry::Vacant(entry) = nodes.entry(id) else { + return Err(SchemaError::DuplicateNode(id))? + }; - match node.which()? { - NodeKind::Struct(s) => { - let type_ident = - identifiers.make_unique(Some(scope.clone()), AsPascalCase(name))?; - let mod_ident = identifiers.make_unique(Some(scope.clone()), AsSnakeCase(name))?; + let type_ident = + identifiers.make_unique(Some(scope.clone()), AsPascalCase(name))?; - let node_info = StructInfo { - type_info: TypeInfo { - type_ident, - scope: scope.clone(), - }, - mod_ident: mod_ident.clone(), - }; + let enumerants = { + let mut idents = IdentifierSet::new(); + schema.enumerants() + .into_iter() + .enumerate() + .map(|(idx, name)| { + let name = name.as_str().map_err(|error| GeneratorError::InvalidName { + context: NameContext::Enumerant { type_id: id, index: idx as u32 }, error + })?; + let ident = idents.make_unique(AsPascalCase(name))?; + Ok(ident) + }) + .collect::>()? + }; - *info = Some(NodeInfo::Struct(node_info)); + entry.insert(NodeInfo::Enum(EnumInfo { + enumerants, + type_info: TypeInfo { + type_ident, + scope: scope.clone(), + }, + })); - scope.push(ModScope { - id: node.id(), - mod_ident, - }); + Ok(()) +} - if s.discriminant_count() != 0 { - // Insert Which into the identifier set so if any conflicts appear they'll - // be made properly unique - let _ = identifiers.make_unique(Some(scope.clone()), "Which")?; - } +fn validate_interface( + schema: &InterfaceSchema<'_>, + _: &str, + nodes: &mut NodeInfoMap, + _: &mut ScopedIdentifierSet, + _: &mut TypeScope, +) -> Result<()> { + let id = schema.node.id(); + let Entry::Vacant(entry) = nodes.entry(id) else { + return Err(SchemaError::DuplicateNode(id))? + }; - Self::validate_scope(&node.clone(), nodes, identifiers, scope)?; + entry.insert(NodeInfo::Interface(InterfaceInfo {})); - scope.pop(); - } - NodeKind::Enum(e) => { - let type_ident = - identifiers.make_unique(Some(scope.clone()), AsPascalCase(name))?; - - let enumerants = { - let mut idents = IdentifierSet::new(); - e.enumerants() - .into_iter() - .map(|e| { - let name = e.name().as_str()?; - let ident = idents.make_unique(AsPascalCase(name))?; - Ok(ident) - }) - .collect::>()? - }; + // do nothing for now - *info = Some(NodeInfo::Enum(EnumInfo { - enumerants, - type_info: TypeInfo { - type_ident, - scope: scope.clone(), - }, - })); - } - NodeKind::Const(_) => { - *info = Some(NodeInfo::Const(ConstInfo { - scope: scope.clone(), - ident: identifiers.make_unique(Some(scope.clone()), AsShoutySnakeCase(name))?, - })) - } - NodeKind::File(()) => unreachable!(), - NodeKind::Interface(_) => { - // todo: generate interface info + Ok(()) +} + +fn validate_const( + schema: &ConstSchema<'_>, + name: &str, + nodes: &mut NodeInfoMap, + identifiers: &mut ScopedIdentifierSet, + scope: &mut TypeScope, +) -> Result<()> { + let id = schema.node.id(); + let Entry::Vacant(entry) = nodes.entry(id) else { + return Err(SchemaError::DuplicateNode(id))? + }; + + entry.insert(NodeInfo::Const(ConstInfo { + scope: scope.clone(), + ident: identifiers.make_unique(Some(scope.clone()), AsShoutySnakeCase(name))?, + })); + + Ok(()) +} + +fn validate_annotation( + schema: &AnnotationSchema<'_>, + _: &str, + nodes: &mut NodeInfoMap, + _: &mut ScopedIdentifierSet, + _: &mut TypeScope, +) -> Result<()> { + let id = schema.node.id(); + let Entry::Vacant(entry) = nodes.entry(id) else { + return Err(SchemaError::DuplicateNode(id))? + }; + + entry.insert(NodeInfo::Annotation(AnnotationInfo {})); + + // do nothing for now + Ok(()) +} + +macro_rules! quote_none { + () => { syn::parse_quote!(::core::option::Option::None) }; +} + +/// Context related to generating a single file +struct FileContext { + required_imports: BTreeSet, +} + +#[derive(Clone, Copy, PartialEq, Eq)] +enum TypeContext { + Field, + Const, +} + +pub struct GeneratorContext { + loader: SchemaLoader, + info: NodeInfoMap, +} + +impl GeneratorContext { + pub fn new(request: &ReaderOf<'_, schema_capnp::CodeGeneratorRequest>) -> Result { + let loader = { + let mut loader = SchemaLoader::new(); + for node in request.nodes() { + loader.load(&node)?; } - NodeKind::Annotation(_) => {} // ignored + loader + }; + let mut info = NodeInfoMap::new(); + let mut identifiers = ScopedIdentifierSet::new(); + + for file in loader.files() { + validate_file(&file, &mut info, &mut identifiers)?; } - Ok(()) + Ok(Self { loader, info }) + } + + fn find_info(&self, id: Id) -> Result<&NodeInfo> { + self.info.get(&id).ok_or(SchemaError::MissingNode(id).into()) } pub fn generate_file(&self, id: u64) -> Result<(GeneratedFile, GeneratedRootFile)> { - let NodeContext { - node, - info: Some(NodeInfo::File(FileInfo { mod_ident, path })), - } = &self.nodes[&id] - else { - anyhow::bail!("expected file node") - }; + let schema: FileSchema<'_> = self.loader.try_schema(id)?; + let info = self.find_info(id)?.unwrap_file(); - let mut required_imports = HashSet::new(); let mut file = GeneratedFile { items: Vec::new(), - ident: mod_ident.clone(), + ident: info.mod_ident.clone(), }; - for nested in node.nested_nodes() { - if let Some(item) = self.generate_item(nested.id(), &mut required_imports)? { + let mut ctx = FileContext { required_imports: BTreeSet::new() }; + + for nested in schema.nested_items() { + let nested = nested?; + if let Some(item) = self.generate_item(nested.id, nested.item, &mut ctx)? { file.items.push(item); } } - let imports = required_imports - .iter() - .map(|id| { - let NodeContext { - info: Some(NodeInfo::File(FileInfo { mod_ident, .. })), - .. - } = &self.nodes[id] - else { - anyhow::bail!("expected imported file node") - }; - - Ok(mod_ident.clone()) - }) - .collect::, _>>()?; - let root_mod = GeneratedRootFile { - ident: mod_ident.clone(), - imports, - path: path.clone(), + let mut root_mod = GeneratedRootFile { + ident: info.mod_ident.clone(), + imports: Vec::with_capacity(ctx.required_imports.len()), + path: info.path.clone(), }; + for import in ctx.required_imports { + let info = self.find_info(import)?.unwrap_file(); + root_mod.imports.push(info.mod_ident.clone()); + } Ok((file, root_mod)) } @@ -395,166 +504,203 @@ impl<'a> GeneratorContext<'a> { fn generate_item( &self, id: u64, - required_imports: &mut HashSet, + item: NestedItem<'_>, + ctx: &mut FileContext, ) -> Result> { - let NodeContext { node, info } = &self.nodes[&id]; - let item = match (node.which()?, info) { - (NodeKind::Struct(s), Some(NodeInfo::Struct(info))) => { - GeneratedItem::Struct(self.generate_struct(node, &s, info, required_imports)?) - } - (NodeKind::Enum(_), Some(NodeInfo::Enum(info))) => { - GeneratedItem::Enum(self.generate_enum(info)?) - } - (NodeKind::Const(c), Some(NodeInfo::Const(info))) => { - GeneratedItem::Const(self.generate_const(&c, info, required_imports)?) - } - (NodeKind::Interface(_), _) => { - // todo: generate interface items - return Ok(None); - } - (NodeKind::Annotation(_), _) => { - // todo: generate annotation items - return Ok(None); - } - (NodeKind::File(()), _) => unreachable!("found nested file node inside a file"), - _ => anyhow::bail!("missing node info"), - }; - Ok(Some(item)) + let info = self.find_info(id)?; + match item { + NestedItem::Struct(schema) => { + let generated = self.generate_struct(&schema, info.unwrap_struct(), ctx)?; + Ok(Some(GeneratedItem::Struct(generated))) + }, + NestedItem::Enum(schema) => { + let generated = self.generate_enum(&schema, info.unwrap_enum(), ctx)?; + Ok(Some(GeneratedItem::Enum(generated))) + }, + NestedItem::Const(schema) => { + let generated = self.generate_const(&schema, info.unwrap_const(), ctx)?; + Ok(Some(GeneratedItem::Const(generated))) + }, + NestedItem::Interface(_) => Ok(None), + NestedItem::Annotation(_) => Ok(None), + } } fn generate_struct( &self, - node: &ReaderOf, - struct_group: &ReaderOf, + schema: &StructSchema<'_>, info: &StructInfo, - required_imports: &mut HashSet, + ctx: &mut FileContext, ) -> Result { - let (fields, variants) = struct_group + let (fields, variants) = schema .fields() .into_iter() - .partition::, _>(|field| field.discriminant_value() == NO_DISCRIMINANT); + .enumerate() // enumerate the fields so we can report name errors better + .partition::, _>(|(_, field)| field.discriminant().is_none()); + + assert_eq!(schema.info.discriminant_count() as usize, variants.len()); + + let size = (!schema.is_group()).then(|| schema.struct_size()); + + let mut generated = GeneratedStruct { + ident: info.type_info.type_ident.clone(), + mod_ident: info.mod_ident.clone(), + type_params: Vec::new(), + size, + fields: Vec::new(), + which: None, + nested_items: Vec::new(), + }; let mut discriminant_idents = IdentifierSet::new(); let mut descriptor_idents = IdentifierSet::new(); let mut accessor_idents = IdentifierSet::new(); - let fields = fields - .into_iter() - .map(|field| { - self.generate_field( - &field, - info, - &mut descriptor_idents, - &mut accessor_idents, - required_imports, - ) - }) - .collect::>()?; + generated.fields.reserve(fields.len()); + for (idx, field) in fields { + let name = field.name().as_str() + .map_err(|error| GeneratorError::InvalidName { + context: NameContext::Field { + type_id: schema.node.id(), + index: idx as u32, + }, + error, + })?; + let field_type = field.field_type()?; + let generated_field = self.generate_field( + &field_type, + name, + info, + &mut descriptor_idents, + &mut accessor_idents, + ctx, + )?; + generated.fields.push(generated_field); + } - assert_eq!(struct_group.discriminant_count() as usize, variants.len()); - let which = if struct_group.discriminant_count() != 0 { + if !variants.is_empty() { + let which = generated.which.insert(GeneratedWhich { + tag_slot: schema.info.discriminant_offset(), + fields: Vec::new(), + type_params: Vec::new(), + }); // Create a scope used for resolving types from within the struct's mod scope. let struct_mod_scope = { let mut struct_scope = info.type_info.scope.clone(); struct_scope.push(ModScope { - id: node.id(), + id: schema.node.id(), mod_ident: info.mod_ident.clone(), }); struct_scope }; - let fields = variants - .into_iter() - .map(|field| { - let name = field.name().as_str()?; - let discriminant_ident = discriminant_idents.make_unique(AsPascalCase(name))?; - - let generated_field = self.generate_field( - &field, - info, - &mut descriptor_idents, - &mut accessor_idents, - required_imports, - )?; - let variant = GeneratedVariant { - discriminant_ident, - discriminant_field_type: self - .field_type(&field, &struct_mod_scope, required_imports)? - .0, - case: field.discriminant_value(), - field: generated_field, - }; - Ok(variant) + which.fields.reserve(variants.len()); + for (idx, field) in variants { + let name = field.name().as_str() + .map_err(|error| GeneratorError::InvalidName { + context: NameContext::Field { + type_id: schema.node.id(), + index: idx as u32, + }, + error, + })?; + let discriminant_ident = discriminant_idents.make_unique(AsPascalCase(name))?; + + let field_type = field.field_type()?; + let generated_field = self.generate_field( + &field_type, + name, + info, + &mut descriptor_idents, + &mut accessor_idents, + ctx, + )?; + which.fields.push(GeneratedVariant { + discriminant_ident, + discriminant_field_type: self.resolve_field_type( + &struct_mod_scope, + &field_type, + ctx, + )?, + case: field.info.discriminant_value(), + field: generated_field, }) - .collect::>()?; - Some(GeneratedWhich { - tag_slot: struct_group.discriminant_offset(), - fields, - type_params: Vec::new(), - }) - } else { - None - }; - - let size = (!struct_group.is_group()).then(|| StructSize { - data: struct_group.data_word_count(), - ptrs: struct_group.pointer_count(), - }); + } + } - let mut nested_items = Vec::new(); - for nested in node.nested_nodes() { - if let Some(item) = self.generate_item(nested.id(), required_imports)? { - nested_items.push(item); + for nested in schema.nested_items() { + let nested = nested?; + if let Some(item) = self.generate_item(nested.id, nested.item, ctx)? { + generated.nested_items.push(item); } } - if let Some(node) = node.r#struct().get() { - for field in node.fields() { - if let Some(group) = field.group().get() { - if let Some(item) = self.generate_item(group.type_id(), required_imports)? { - nested_items.push(item); - } - } + for field in schema.fields() { + if let FieldType::Group(group) = field.field_type()? { + let info = self.find_info(group.node.id())?.unwrap_struct(); + let item = self.generate_struct(&group, info, ctx)?; + generated.nested_items.push(GeneratedItem::Struct(item)); } } - Ok(GeneratedStruct { - ident: info.type_info.type_ident.clone(), - mod_ident: info.mod_ident.clone(), - type_params: Vec::new(), - size, - fields, - which, - nested_items, - }) + Ok(generated) } fn generate_field( &self, - field: &ReaderOf, + field_type: &FieldType<'_>, + name: &str, StructInfo { type_info: TypeInfo { type_ident, scope }, .. }: &StructInfo, descriptor_idents: &mut IdentifierSet, accessor_idents: &mut IdentifierSet, - required_imports: &mut HashSet, + ctx: &mut FileContext, ) -> Result { - let name = field.name().as_str()?; let accessor_ident = accessor_idents.make_unique(AsSnakeCase(name))?; let descriptor_ident = descriptor_idents.make_unique(AsShoutySnakeCase(name))?; - let (field_type, kind) = self.field_type(field, scope, required_imports)?; - let descriptor = self.descriptor(field, scope, required_imports)?; - let type_name = type_ident.clone(); - let own_accessor_ident = match kind { - FieldKind::Data => None, - FieldKind::Pointer => { - Some(accessor_idents.make_unique(AsSnakeCase(format!("into_{name}")))?) - } + + let has_own_accessor; + let descriptor; + match field_type { + FieldType::Group(..) => { + has_own_accessor = true; + descriptor = None; + }, + FieldType::Slot { field_type, offset, default_value } => { + has_own_accessor = field_type.is_ptr_field(); + let void_field = matches!( + field_type, + Type { list_depth: 0, kind: TypeKind::Void }, + ); + descriptor = if void_field { + None + } else { + let default_value = match default_value { + Some(default) => self.generate_field_default_value( + scope, + &field_type, + &default, + ), + None => self.generate_field_default_for_type(scope, &field_type), + }?; + Some(FieldDescriptor { + slot: *offset, + default: default_value, + }) + }; + }, + }; + let syn_type = self.resolve_field_type(scope, field_type, ctx)?; + let own_accessor_ident = if has_own_accessor { + Some(accessor_idents.make_unique(AsSnakeCase(format!("into_{name}")))?) + } else { + None }; Ok(GeneratedField { - type_name, - field_type, + type_name: type_ident.clone(), + field_type: syn_type, own_accessor_ident, accessor_ident, descriptor_ident, @@ -562,287 +708,280 @@ impl<'a> GeneratorContext<'a> { }) } - fn field_type( + fn resolve_field_type( &self, - field: &ReaderOf, scope: &TypeScope, - required_imports: &mut HashSet, - ) -> Result<(Box, FieldKind)> { - match field.which()? { - schema::field::Which::Slot(slot) => { - let type_info = slot.r#type().get(); - let syn_type = self.resolve_type(scope, &type_info, required_imports)?; - let kind = FieldKind::from_proto(&type_info)?; - Ok((syn_type, kind)) - } - schema::field::Which::Group(group) => { - let type_name = self.resolve_type_name(scope, group.type_id(), required_imports)?; - let syn_type = Box::new(syn::parse_quote!(_p::Group<#type_name>)); - Ok((syn_type, FieldKind::Pointer)) - } - } + field_type: &FieldType<'_>, + ctx: &mut FileContext, + ) -> Result> { + Ok(match field_type { + FieldType::Group(group) => { + let group_type = &self.find_info(group.node.id())?.unwrap_struct().type_info; + let path = group_type.resolve_path(scope); + Box::new(syn::parse_quote!(_p::Group<#path>)) + }, + FieldType::Slot { field_type, .. } => { + self.resolve_type(scope, &field_type, TypeContext::Field, ctx)? + }, + }) } - fn descriptor( + fn resolve_type( &self, - field: &ReaderOf, scope: &TypeScope, - required_imports: &mut HashSet, - ) -> Result> { - Ok(match field.which()? { - schema::field::Which::Slot(slot) => { - let type_info = slot.r#type().get(); - if type_info.void().is_set() { - None + info: &Type<'_>, + ty_ctx: TypeContext, + ctx: &mut FileContext, + ) -> Result> { + let mut rust_ty = match &info.kind { + TypeKind::Void => syn::parse_quote!(()), + TypeKind::Bool => syn::parse_quote!(bool), + TypeKind::Int8 => syn::parse_quote!(i8), + TypeKind::Int16 => syn::parse_quote!(i16), + TypeKind::Int32 => syn::parse_quote!(i32), + TypeKind::Int64 => syn::parse_quote!(i64), + TypeKind::Uint8 => syn::parse_quote!(u8), + TypeKind::Uint16 => syn::parse_quote!(u16), + TypeKind::Uint32 => syn::parse_quote!(u32), + TypeKind::Uint64 => syn::parse_quote!(u64), + TypeKind::Float32 => syn::parse_quote!(f32), + TypeKind::Float64 => syn::parse_quote!(f64), + TypeKind::Enum { schema, .. } => { + let type_info = &self.find_info(schema.node.id())?.unwrap_enum().type_info; + if type_info.scope.file != scope.file { + ctx.required_imports.insert(type_info.scope.file.id); + } + + let path = type_info.resolve_path(scope); + if ty_ctx == TypeContext::Const && !info.is_list() { + syn::parse_quote!(#path) } else { - let default_value = slot.default_value().get_option(); - let value = self.generate_value( - scope, - &type_info, - default_value.as_ref(), - required_imports, - )?; - Some(FieldDescriptor { - slot: slot.offset(), - default: value, - }) + syn::parse_quote!(_p::Enum<#path>) } - } - schema::field::Which::Group(_) => None, - }) + }, + TypeKind::Data => syn::parse_quote!(_p::Data), + TypeKind::Text => syn::parse_quote!(_p::Text), + TypeKind::Struct { schema, .. } => { + let type_info = &self.find_info(schema.node.id())?.unwrap_struct().type_info; + if type_info.scope.file != scope.file { + ctx.required_imports.insert(type_info.scope.file.id); + } + + let path = type_info.resolve_path(scope); + syn::parse_quote!(_p::Struct<#path>) + }, + TypeKind::Interface { .. } => syn::parse_quote!(_p::AnyPtr), // TODO + TypeKind::AnyPointer => syn::parse_quote!(_p::AnyPtr), + TypeKind::AnyStruct => syn::parse_quote!(_p::AnyStruct), + TypeKind::AnyList => syn::parse_quote!(_p::AnyList), + TypeKind::AnyCapability => syn::parse_quote!(_p::AnyPtr), // TODO + TypeKind::ScopeBound { .. } => syn::parse_quote!(_p::AnyPtr), // TODO + TypeKind::ImplicitMethodParameter { .. } => syn::parse_quote!(_p::AnyPtr), // TODO + }; + for _ in 0..info.list_depth { + rust_ty = syn::parse_quote!(_p::List<#rust_ty>); + } + if ty_ctx == TypeContext::Const && info.is_ptr_field() { + rust_ty = syn::parse_quote!(_p::ty::ConstPtr<#rust_ty>) + } + Ok(rust_ty) } - fn resolve_type( + fn generate_field_default_for_type( &self, scope: &TypeScope, - info: &ReaderOf, - required_imports: &mut HashSet, - ) -> Result> { - Ok(Box::new(match info.which()? { - TypeKind::Void(()) => syn::parse_quote!(()), - TypeKind::Bool(()) => syn::parse_quote!(bool), - TypeKind::Int8(()) => syn::parse_quote!(i8), - TypeKind::Uint8(()) => syn::parse_quote!(u8), - TypeKind::Int16(()) => syn::parse_quote!(i16), - TypeKind::Uint16(()) => syn::parse_quote!(u16), - TypeKind::Int32(()) => syn::parse_quote!(i32), - TypeKind::Uint32(()) => syn::parse_quote!(u32), - TypeKind::Int64(()) => syn::parse_quote!(i64), - TypeKind::Uint64(()) => syn::parse_quote!(u64), - TypeKind::Float32(()) => syn::parse_quote!(f32), - TypeKind::Float64(()) => syn::parse_quote!(f64), - TypeKind::Text(()) => syn::parse_quote!(_p::Text), - TypeKind::Data(()) => syn::parse_quote!(_p::Data), - TypeKind::List(list) => { - let element_type = list.element_type().get(); - let resolved = self.resolve_type(scope, &element_type, required_imports)?; - syn::parse_quote!(_p::List<#resolved>) - } - TypeKind::Enum(e) => { - let type_name = self.resolve_type_name(scope, e.type_id(), required_imports)?; - syn::parse_quote!(_p::Enum<#type_name>) - } - TypeKind::Struct(s) => { - let type_name = self.resolve_type_name(scope, s.type_id(), required_imports)?; - syn::parse_quote!(_p::Struct<#type_name>) - } - TypeKind::Interface(_) => syn::parse_quote!(_p::AnyPtr), // TODO - TypeKind::AnyPointer(ptr) => match ptr.which()? { - AnyPtrKind::Unconstrained(unconstrained) => match unconstrained.which()? { - ConstraintKind::AnyKind(()) => syn::parse_quote!(_p::AnyPtr), - ConstraintKind::Struct(()) => syn::parse_quote!(_p::AnyStruct), - ConstraintKind::List(()) => syn::parse_quote!(_p::AnyList), - ConstraintKind::Capability(()) => syn::parse_quote!(_p::AnyPtr), // TODO - }, - AnyPtrKind::Parameter(_) => syn::parse_quote!(_p::AnyPtr), // TODO - AnyPtrKind::ImplicitMethodParameter(_) => todo!(), + info: &Type<'_>, + ) -> Result> { + if info.list_depth != 0 { + return Ok(quote_none!()) + } + use TypeKind::*; + let tokens = match &info.kind { + Void => syn::parse_quote!(()), + Bool => syn::parse_quote!(false), + Int8 => syn::parse_quote!(0i8), + Int16 => syn::parse_quote!(0i16), + Int32 => syn::parse_quote!(0i32), + Int64 => syn::parse_quote!(0i64), + Uint8 => syn::parse_quote!(0u8), + Uint16 => syn::parse_quote!(0u16), + Uint32 => syn::parse_quote!(0u32), + Uint64 => syn::parse_quote!(0u64), + Float32 => syn::parse_quote!(0.0f32), + Float64 => syn::parse_quote!(0.0f64), + Enum { schema, .. } => { + let info = self.find_info(schema.node.id())?.unwrap_enum(); + let type_name = info.type_info.resolve_path(scope); + let enumerant = &info.enumerants[0]; + + syn::parse_quote!(#type_name::#enumerant) }, - })) + Data | Text | Struct { .. } | Interface { .. } | AnyPointer | AnyStruct | AnyList | + AnyCapability | ScopeBound { .. } | ImplicitMethodParameter { .. } => quote_none!(), + }; + + Ok(tokens) } - fn resolve_type_name( + fn generate_field_default_value( &self, - ref_scope: &TypeScope, - id: u64, - required_imports: &mut HashSet, - ) -> Result { - let Some(info) = &self.nodes[&id].info else { - anyhow::bail!("missing type info for {}", id) - }; - match info { - NodeInfo::Struct(StructInfo { type_info, .. }) - | NodeInfo::Enum(EnumInfo { type_info, .. }) => { - if type_info.scope.file != ref_scope.file { - let _ = required_imports.insert(type_info.scope.file.id); - } + scope: &TypeScope, + type_info: &Type<'_>, + value: &ReaderOf<'_, schema_capnp::Value>, + ) -> Result> { + if type_info.is_list() { + let value = value.list() + .field() + .and_then(|v| v.ptr().read_option_as::()) + .filter(|l| !l.is_empty()); + return Ok(if let Some(value) = value { + let value_element_size = value.element_size(); + + // Now check to make sure we're making a valid pointer for this element type. Since we're + // going to make an unchecked pointer into the data we have to do this check beforehand. + // capnpc should give us the same element size as what the type is, but this acts as a + // simple sanity check. + let expected_element_size = if type_info.is_list_of_lists() { + ElementSize::Pointer + } else { + use TypeKind::*; + match &type_info.kind { + Void => ElementSize::Void, + Bool => ElementSize::Bit, + Int8 | Uint8 => ElementSize::Byte, + Int16 | Uint16 | Enum { .. } => ElementSize::TwoBytes, + Int32 | Uint32 | Float32 => ElementSize::FourBytes, + Int64 | Uint64 | Float64 => ElementSize::EightBytes, + Struct { schema, .. } => + ElementSize::InlineComposite(schema.struct_size()), + AnyStruct => { + assert!( + value_element_size.is_inline_composite(), + "expected inline composite elements for list of any struct" + ); + value_element_size + }, + _ => ElementSize::Pointer, + } + }; - Ok(type_info.resolve_path(ref_scope)) - } - NodeInfo::File(_) | NodeInfo::Const(_) => anyhow::bail!("unexpected node type"), + assert_eq!(value_element_size, expected_element_size); + + let expr = generate_untyped_list_value(&value); + syn::parse_quote!(::core::option::Option::Some(#expr)) + } else { + quote_none!() + }); + } + + if type_info.is_data_field() { + return self.generate_data_value(scope, &type_info.kind, value) } + + // Now we just need to handle the other pointer field types! + let expr = match &type_info.kind { + TypeKind::Text => value + .text() + .field() + .map(|v| v.get()) + .filter(|t| !t.is_empty()) + .map_or_else(|| quote_none!(), |text| { + let expr = text_to_expr(text); + syn::parse_quote!(::core::option::Option::Some(#expr)) + }), + TypeKind::Data => value + .data() + .field() + .map(|v| v.get()) + .filter(|d| !d.is_empty()) + .map_or_else(|| quote_none!(), |data| { + let expr = data_to_expr(data); + syn::parse_quote!(::core::option::Option::Some(#expr)) + }), + TypeKind::Struct { schema, .. } => value + .r#struct() + .field() + .and_then(|f| f.ptr().read_option_as::()) + .filter(|s| !s.as_ref().size().is_empty()) + .map_or_else(|| quote_none!(), |s| { + assert_eq!(schema.struct_size(), s.as_ref().size()); + + let expr = generate_untyped_struct_value(&s); + syn::parse_quote!(::core::option::Option::Some(#expr)) + }), + TypeKind::AnyPointer => value + .any_pointer() + .field() + .map(|f| f.ptr()) + .filter(|p| p.is_null()) + .map_or_else(|| quote_none!(), |p| { + let expr = generate_untyped_ptr_value(&p); + syn::parse_quote!(::core::option::Option::Some(#expr)) + }), + TypeKind::AnyStruct => value + .any_pointer() + .field() + .and_then(|p| p.ptr().read_option_as::()) + .filter(|s| !s.as_ref().size().is_empty()) + .map_or_else(|| quote_none!(), |s| { + let expr = generate_untyped_struct_value(&s); + syn::parse_quote!(::core::option::Option::Some(#expr)) + }), + TypeKind::AnyList => value + .any_pointer() + .field() + .and_then(|p| p.ptr().read_option_as::()) + .filter(|s| !s.is_empty()) + .map_or_else(|| quote_none!(), |l| { + let expr = generate_untyped_list_value(&l); + syn::parse_quote!(::core::option::Option::Some(#expr)) + }), + TypeKind::Interface { .. } | + TypeKind::AnyCapability | + TypeKind::ScopeBound { .. } | + TypeKind::ImplicitMethodParameter { .. } => quote_none!(), + _ => unimplemented!(), + }; + + Ok(expr) } - fn generate_value( + fn generate_data_value( &self, scope: &TypeScope, - type_info: &ReaderOf, - value: Option<&ReaderOf>, - required_imports: &mut HashSet, - ) -> Result { + type_info: &TypeKind<'_>, + value: &ReaderOf<'_, schema_capnp::Value>, + ) -> Result> { macro_rules! value_or_default { ($field:ident) => {{ - let value = value.and_then(|v| v.$field().get()).unwrap_or_default(); - quote!(#value) + let value = value.$field().get().unwrap_or_default(); + syn::parse_quote!(#value) }}; } - let expr = match type_info.which()? { - TypeKind::Void(()) => quote!(()), - TypeKind::Bool(()) => value_or_default!(bool), - TypeKind::Int8(()) => value_or_default!(int8), - TypeKind::Uint8(()) => value_or_default!(uint8), - TypeKind::Int16(()) => value_or_default!(int16), - TypeKind::Uint16(()) => value_or_default!(uint16), - TypeKind::Int32(()) => value_or_default!(int32), - TypeKind::Uint32(()) => value_or_default!(uint32), - TypeKind::Int64(()) => value_or_default!(int64), - TypeKind::Uint64(()) => value_or_default!(uint64), - TypeKind::Float32(()) => value_or_default!(float32), - TypeKind::Float64(()) => value_or_default!(float64), - TypeKind::Text(()) => match value.and_then(|v| v.text().field()).map(|v| v.get()) { - Some(text) if !text.is_empty() => { - let bytes = syn::LitByteStr::new( - text.as_bytes_with_nul(), - proc_macro2::Span::call_site(), - ); - - quote!(_p::text::Reader::from_slice(#bytes)) - } - _ => quote!(None), - }, - TypeKind::Data(()) => match value.and_then(|v| v.data().field()).map(|v| v.get()) { - Some(data) if !data.is_empty() => { - let bytes = - syn::LitByteStr::new(data.as_slice(), proc_macro2::Span::call_site()); - - quote!(_p::data::Reader::from_slice(#bytes)) - } - _ => quote!(None), - }, - TypeKind::List(list) => { - let element_type = list.element_type().get(); - let element_type_quote = - self.resolve_type(scope, &element_type, required_imports)?; - let default_value = value - .and_then(|v| v.list().field()) - .map(|v| v.ptr().read_as::()); - let element_size_quote = quote!(_p::ElementSize::size_of::<#element_type_quote>()); - match default_value { - Some(list) if !list.is_empty() => { - let result = list_to_slice(&list); - // Remove the root pointer since we're going to create a direct pointer - // to the data itself which must be allocated immediately after it. - let words = words_lit(result.split_first().unwrap().1); - let len = list.len(); - let element_size = list.as_ref().element_size(); - - assert_eq!(element_size, self.type_element_size(&element_type)?); - - quote!(_p::ListReader::slice_unchecked(#words, #len, #element_size_quote)) - } - _ => quote!(None), - } - } - TypeKind::Enum(info) => { - let value = value.and_then(|v| v.r#enum().get()).unwrap_or(0); - let NodeContext { - info: - Some(NodeInfo::Enum(EnumInfo { - enumerants, - type_info, - })), - .. - } = &self.nodes[&info.type_id()] - else { - anyhow::bail!("expected enum node") - }; - let type_name = type_info.resolve_path(scope); - let enumerant = &enumerants[value as usize]; - - quote!(#type_name::#enumerant) - } - TypeKind::Struct(_) => { - let any = value - .and_then(|v| v.r#struct().field()) - .and_then(|v| v.ptr().try_read_option_as::().ok().flatten()); - match any { - Some(value) if !value.as_ref().size().is_empty() => { - let result = struct_to_slice(&value); - // Remove the root pointer since we're going to create a direct pointer - // to the data itself which must be allocated immediately after it. - let words = words_lit(result.split_first().unwrap().1); - let StructSize { data, ptrs } = value.as_ref().size(); - let size = quote!(_p::StructSize { data: #data, ptrs: #ptrs }); - - quote!(_p::StructReader::slice_unchecked(#words, #size)) - } - _ => quote!(None), - } - } - TypeKind::Interface(_) => quote!(None), - TypeKind::AnyPointer(kind) => { - let ptr = value - .and_then(|v| v.any_pointer().field()) - .map(|p| p.ptr()) - .filter(|p| !p.is_null()); - match kind.which()? { - AnyPtrKind::Unconstrained(unconstrained) => match unconstrained.which()? { - ConstraintKind::AnyKind(_) => { - if let Some(ptr) = ptr { - let slice = ptr_to_slice(&ptr); - let words = words_lit(&slice); - - quote!(_p::PtrReader::slice_unchecked(#words)) - } else { - quote!(None) - } - } - ConstraintKind::Struct(_) => { - if let Some(ptr) = ptr { - let reader = ptr - .try_read_as::() - .expect("struct pointer value is not struct!"); - let slice = struct_to_slice(&reader); - let words = words_lit(slice.split_first().unwrap().1); - let StructSize { data, ptrs } = reader.as_ref().size(); - let size = quote!(_p::StructSize { data: #data, ptrs: #ptrs }); - - quote!(_p::StructReader::slice_unchecked(#words, #size)) - } else { - quote!(None) - } - } - ConstraintKind::List(_) => { - if let Some(ptr) = ptr { - let reader = ptr - .try_read_as::() - .expect("list pointer value is not list!"); - let slice = list_to_slice(&reader); - let words = words_lit(slice.split_first().unwrap().1); - let len = reader.len(); - let size_quote = element_size_to_tokens(reader.element_size()); - - quote!(_p::ListReader::slice_unchecked(#words, #len, #size_quote)) - } else { - quote!(None) - } - } - ConstraintKind::Capability(_) => quote!(None), - }, - AnyPtrKind::Parameter(_) => quote!(None), - _ => unreachable!(), - } + let expr = match type_info { + TypeKind::Void => syn::parse_quote!(()), + TypeKind::Bool => value_or_default!(bool), + TypeKind::Int8 => value_or_default!(int8), + TypeKind::Uint8 => value_or_default!(uint8), + TypeKind::Int16 => value_or_default!(int16), + TypeKind::Uint16 => value_or_default!(uint16), + TypeKind::Int32 => value_or_default!(int32), + TypeKind::Uint32 => value_or_default!(uint32), + TypeKind::Int64 => value_or_default!(int64), + TypeKind::Uint64 => value_or_default!(uint64), + TypeKind::Float32 => value_or_default!(float32), + TypeKind::Float64 => value_or_default!(float64), + TypeKind::Enum { schema, .. } => { + let value = value.r#enum().get().unwrap_or(0); + let info = self.find_info(schema.node.id())?.unwrap_enum(); + + let type_path = info.type_info.resolve_path(scope); + let enumerant = &info.enumerants[value as usize]; + + syn::parse_quote!(#type_path::#enumerant) } + _ => unimplemented!() }; Ok(expr) @@ -850,10 +989,12 @@ impl<'a> GeneratorContext<'a> { fn generate_enum( &self, + _: &EnumSchema<'_>, EnumInfo { type_info: TypeInfo { type_ident, .. }, enumerants, }: &EnumInfo, + _: &mut FileContext, ) -> Result { Ok(GeneratedEnum { name: type_ident.clone(), @@ -863,57 +1004,114 @@ impl<'a> GeneratorContext<'a> { fn generate_const( &self, - node: &ReaderOf, + schema: &ConstSchema<'_>, info: &ConstInfo, - required_imports: &mut HashSet, + ctx: &mut FileContext, ) -> Result { - let type_info = node.r#type().get(); + let t = schema.value_type()?; + let v = schema.value(); Ok(GeneratedConst { ident: info.ident.clone(), - const_type: self.resolve_type(&info.scope, &type_info, required_imports)?, - value: self.generate_value( - &info.scope, - &type_info, - node.value().get_option().as_ref(), - required_imports, - )?, + const_type: self.resolve_type(&info.scope, &t, TypeContext::Const, ctx)?, + value: self.generate_const_value(&info.scope, &t, &v)?, }) } - fn type_element_size(&self, ty: &ReaderOf) -> Result { - use ElementSize::*; - Ok(match ty.which()? { - TypeKind::Void(_) => Void, - TypeKind::Bool(_) => Bit, - TypeKind::Int8(_) | TypeKind::Uint8(_) => Byte, - TypeKind::Int16(_) | TypeKind::Uint16(_) | TypeKind::Enum(_) => TwoBytes, - TypeKind::Int32(_) | TypeKind::Uint32(_) | TypeKind::Float32(_) => FourBytes, - TypeKind::Int64(_) | TypeKind::Uint64(_) | TypeKind::Float64(_) => EightBytes, - TypeKind::Text(_) - | TypeKind::Data(_) - | TypeKind::List(_) - | TypeKind::Interface(_) - | TypeKind::AnyPointer(_) => Pointer, - TypeKind::Struct(s) => { - let s = self.nodes[&s.type_id()].node.r#struct().get_or_default(); - InlineComposite(StructSize { - data: s.data_word_count(), - ptrs: s.pointer_count(), - }) + fn generate_const_value( + &self, + scope: &TypeScope, + type_info: &Type<'_>, + value: &ReaderOf<'_, schema_capnp::Value>, + ) -> Result> { + if type_info.is_data_field() { + return self.generate_data_value(scope, &type_info.kind, value) + } + + let ptr = if type_info.is_list() { + value.list() + .field() + .map_or_else( + || any::PtrReader::default(), + |f| f.ptr(), + ) + } else { + // Extract the correct pointer value field. + match type_info.kind { + TypeKind::Text => value.text() + .field() + .map_or_else( + || any::PtrReader::default(), + |f| f.ptr(), + ), + TypeKind::Data => value.data() + .field() + .map_or_else( + || any::PtrReader::default(), + |f| f.ptr(), + ), + TypeKind::Struct { .. } => value.r#struct() + .field() + .map_or_else( + || any::PtrReader::default(), + |f| f.ptr(), + ), + TypeKind::Interface { .. } => any::PtrReader::default(), + _ => value.any_pointer() + .field() + .map_or_else( + || any::PtrReader::default(), + |f| f.ptr(), + ), } - }) + }; + + let expr = if ptr.is_null() { + syn::parse_quote!(_p::ty::ConstPtr::null()) + } else { + let slice = ptr_to_slice(&ptr); + let words = words_lit(&slice); + + syn::parse_quote!(unsafe { _p::ty::ConstPtr::new(#words) }) + }; + + Ok(expr) } } fn words_lit(words: &[Word]) -> TokenStream { let words = words.iter().map(|Word([b0, b1, b2, b3, b4, b5, b6, b7])| { - quote!(Word([#b0, #b1, #b2, #b3, #b4, #b5, #b6, #b7])) + quote!(_p::Word([#b0, #b1, #b2, #b3, #b4, #b5, #b6, #b7])) }); quote!(&[#(#words),*]) } -fn ptr_to_slice(p: &any::PtrReader) -> Box<[Word]> { +fn text_to_expr(text: text::Reader<'_>) -> Box { + let bytes = syn::LitByteStr::new( + text.as_bytes_with_nul(), + proc_macro2::Span::call_site(), + ); + + syn::parse_quote!(_p::text::Reader::from_slice(#bytes)) +} + +fn data_to_expr(data: data::Reader<'_>) -> Box { + let bytes = syn::LitByteStr::new( + data.as_ref(), + proc_macro2::Span::call_site(), + ); + + syn::parse_quote!(_p::data::Reader::from_slice(#bytes)) +} + +fn generate_untyped_ptr_value(s: &any::PtrReader<'_>) -> Box { + let slice = ptr_to_slice(s); + let words = words_lit(&slice); + + syn::parse_quote!(unsafe { _p::PtrReader::slice_unchecked(#words) }) +} + +fn ptr_to_slice(p: &any::PtrReader<'_>) -> Box<[Word]> { let size = p .target_size() .expect("failed to calculate size of struct default"); @@ -949,7 +1147,17 @@ fn ptr_to_slice(p: &any::PtrReader) -> Box<[Word]> { space } -fn struct_to_slice(s: &any::StructReader) -> Box<[Word]> { +fn generate_untyped_struct_value(s: &any::StructReader<'_>) -> Box { + let slice = struct_to_slice(s); + let words = words_lit(slice.split_first().unwrap().1); + let StructSize { data, ptrs } = s.as_ref().size(); + let size = quote!(_p::StructSize { data: #data, ptrs: #ptrs }); + + syn::parse_quote!(unsafe { _p::StructReader::slice_unchecked(#words, #size) }) +} + +/// Deep-clone a struct into an array of words without the root pointer. +fn struct_to_slice(s: &any::StructReader<'_>) -> Box<[Word]> { let size = s.total_size().expect("failed to calculate size of struct"); assert_eq!(size.caps, 0, "struct contains caps!"); assert!( @@ -983,7 +1191,21 @@ fn struct_to_slice(s: &any::StructReader) -> Box<[Word]> { space } -fn list_to_slice(l: &any::ListReader) -> Box<[Word]> { +fn generate_untyped_list_value(list: &any::ListReader<'_>) -> Box { + let result = list_to_slice(list); + // Remove the root pointer since we're going to create a direct pointer + // to the data itself which must be allocated immediately after it. + let words = words_lit(result.split_first().unwrap().1); + let len = list.len(); + let value_element_size = list.as_ref().element_size(); + + let element_size_quote = element_size_to_tokens(value_element_size); + + syn::parse_quote!(unsafe { _p::ListReader::slice_unchecked(#words, #len, #element_size_quote) }) +} + +/// Deep-clone a list into an array of words without the root pointer. +fn list_to_slice(l: &any::ListReader<'_>) -> Box<[Word]> { let size = l .total_size() .expect("failed to calculate size of list value"); diff --git a/recapnc/src/generator/ident.rs b/recapnc/src/generator/ident.rs index 6da728b..8047373 100644 --- a/recapnc/src/generator/ident.rs +++ b/recapnc/src/generator/ident.rs @@ -1,19 +1,23 @@ use std::collections::HashSet; use std::hash::Hash; -use anyhow::{ensure, Result}; +use crate::generator::GeneratorError; +use crate::Result; fn make_ident(s: &str) -> Result { let mut ident_str = make_ident_str(s)?; - syn::parse_str(&ident_str).or_else(|_| { + let res = syn::parse_str(&ident_str).unwrap_or_else(|_| { ident_str.insert_str(0, "r#"); - syn::parse_str(&ident_str).map_err(Into::into) - }) + syn::parse_str::(&ident_str).expect("valid identifier string") + }); + Ok(res) } // Convert a string into a valid identifier string by replacing invalid characters with underscores. fn make_ident_str(s: &str) -> Result { - ensure!(!s.is_empty(), "identifier string cannot be empty"); + if s.is_empty() { + return Err(GeneratorError::EmptyName.into()) + } let mut output = String::with_capacity(s.len()); diff --git a/recapnc/src/lib.rs b/recapnc/src/lib.rs index 02b1b77..613bb5f 100644 --- a/recapnc/src/lib.rs +++ b/recapnc/src/lib.rs @@ -407,28 +407,48 @@ pub mod prelude { pub mod generator; pub mod quotes; +pub mod schema; -use anyhow::Context; -use quote::ToTokens; -use recapn::io::{self, StreamOptions}; -use recapn::message::{Reader, ReaderOptions}; -use recapn::ReaderOf; use std::ffi::{OsStr, OsString}; use std::io::Read; -use std::path::Path; +use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; use std::{env, fs}; +use thiserror::Error; +use quote::ToTokens; +use recapn::io::{self, StreamOptions}; +use recapn::message::{Reader, ReaderOptions}; +use recapn::ReaderOf; use gen::capnp_schema_capnp::CodeGeneratorRequest; use generator::GeneratorContext; use quotes::GeneratedRoot; +#[derive(Debug, Error)] +pub enum Error { + #[error("invalid cap'n proto data")] + Recapn(#[from] recapn::Error), + #[error("invalid cap'n proto message stream")] + Stream(#[from] recapn::io::StreamError), + #[error("invalid schema")] + Schema(#[from] schema::SchemaError), + #[error(transparent)] + Generator(#[from] generator::GeneratorError), + #[error("failed to write file at {}: {}", .path.display(), .error)] + FileWrite { + path: PathBuf, + error: std::io::Error, + }, +} + +pub type Result = core::result::Result; + /// Read from an existing `CodeGeneratorRequest` and write files based on the given output path. pub fn generate_from_request( - request: &ReaderOf, + request: &ReaderOf<'_, CodeGeneratorRequest>, out: impl AsRef, -) -> anyhow::Result<()> { +) -> Result<()> { let out = out.as_ref(); let context = GeneratorContext::new(request)?; @@ -437,30 +457,37 @@ pub fn generate_from_request( for file in request.requested_files() { let (file, root) = context.generate_file(file.id())?; - let parsed = - syn::parse2::(file.to_token_stream()).context("parsing generated file")?; + let parsed = syn::parse2::(file.to_token_stream()) + .expect("generated code is valid syn file"); let printable = prettyplease::unparse(&parsed); let out_path = out.join(Path::new(&root.path)); if let Some(parent) = out_path.parent() { let _ = fs::create_dir_all(parent); } - fs::write(&out_path, printable) - .with_context(|| format!("failed to write to path: {}", out_path.display()))?; + + if let Err(err) = fs::write(&out_path, printable) { + return Err(Error::FileWrite { path: out_path, error: err }) + } root_mod.files.push(root); } - let parsed = - syn::parse2::(root_mod.to_token_stream()).context("parsing generated file")?; + let parsed = syn::parse2::(root_mod.to_token_stream()) + .expect("generated code is valid syn file"); + let printable = prettyplease::unparse(&parsed); - fs::write(out.join("mod.rs"), printable)?; + + let mod_path = out.join("mod.rs"); + if let Err(error) = fs::write(&mod_path, printable) { + return Err(Error::FileWrite { path: mod_path, error }) + } Ok(()) } /// Read a `CodeGeneratorRequest` capnp message from a stream and write files based on the given output path. -pub fn generate_from_request_stream(r: impl Read, out: impl AsRef) -> anyhow::Result<()> { +pub fn generate_from_request_stream(r: impl Read, out: impl AsRef) -> Result<()> { let message = io::read_from_stream(r, StreamOptions::default())?; let reader = Reader::new(&message, ReaderOptions::default()); let request = reader.root().read_as_struct::(); diff --git a/recapnc/src/quotes.rs b/recapnc/src/quotes.rs index b906a19..b2b624a 100644 --- a/recapnc/src/quotes.rs +++ b/recapnc/src/quotes.rs @@ -441,7 +441,7 @@ pub struct GeneratedField { pub struct FieldDescriptor { pub slot: u32, - pub default: TokenStream, + pub default: Box, } impl GeneratedField { @@ -729,7 +729,7 @@ to_tokens!( pub struct GeneratedConst { pub ident: syn::Ident, pub const_type: Box, - pub value: TokenStream, + pub value: Box, } to_tokens!( diff --git a/recapnc/src/schema.rs b/recapnc/src/schema.rs new file mode 100644 index 0000000..b1c7016 --- /dev/null +++ b/recapnc/src/schema.rs @@ -0,0 +1,618 @@ +use std::collections::{HashMap, VecDeque}; +use std::fmt; +use std::ptr::NonNull; + +use recapn::alloc::{self, Segment, AllocLen, Word}; +use recapn::ptr::{PtrReader, ReturnErrors, StructSize}; +use recapn::{any, text, NotInSchema, ReaderOf}; + +pub use crate::gen::capnp_schema_capnp as schema_capnp; + +use schema_capnp::{ + Brand, Node, Field, + node::{Annotation, Const, Enum, Interface, Struct, Which as NodeKind}, +}; +use crate::Result; + +use self::schema_capnp::Value; + +struct UncheckedNode { + data: Box<[Word]>, +} + +impl UncheckedNode { + pub fn new(node: &ReaderOf<'_, Node>) -> Result { + let size = node.as_ref().total_size()?; + if size.caps != 0 { + return Err(recapn::Error::CapabilityNotAllowed)? + } + + let Some(len) = size.words + .checked_add(1) + .and_then(|s| u32::try_from(s).ok()) + .and_then(AllocLen::new) else { + return Err(SchemaError::NodeTooLarge)? + }; + + let mut space = vec![Word::NULL; len.get() as usize].into_boxed_slice(); + let segment = Segment { + data: NonNull::new(space.as_mut_ptr()).unwrap(), + len: len.into(), + }; + let alloc = unsafe { alloc::Scratch::with_segment(segment, alloc::Never) }; + + let mut message = recapn::message::Message::new(alloc); + let mut builder = message.builder(); + builder + .by_ref() + .into_root() + .try_set_struct::(node, ReturnErrors)?; + + Ok(UncheckedNode { data: space }) + } + + pub fn get(&self) -> ReaderOf<'_, Node> { + let data = NonNull::new(self.data.as_ptr().cast_mut()).unwrap(); + let ptr = unsafe { PtrReader::new_unchecked(data) }; + any::PtrReader::from(ptr).read_as_struct::() + } +} + +#[derive(Debug)] +pub enum SchemaError { + NodeTooLarge, + DuplicateNode(Id), + MissingNode(Id), + InvalidNestedNode(Id), + UnknownNodeType(NotInSchema), + UnknownFieldType(NotInSchema), + UnknownType(NotInSchema), + UnknownAnyType(NotInSchema), + UnknownPointerType(NotInSchema), + UnknownScopeBinding(NotInSchema), + UnexpectedNodeType, + InvalidBrandType, +} + +impl fmt::Display for SchemaError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + SchemaError::NodeTooLarge => write!(f, "node too large"), + SchemaError::DuplicateNode(id) => write!(f, "duplicate node {}", id), + SchemaError::MissingNode(id) => write!(f, "missing node {}", id), + SchemaError::InvalidNestedNode(id) => write!(f, "invalid nested node {}", id), + SchemaError::UnknownNodeType(NotInSchema(variant)) => + write!(f, "unknown node type {}", variant), + SchemaError::UnknownType(NotInSchema(variant)) => + write!(f, "unknown type {}", variant), + SchemaError::UnknownFieldType(NotInSchema(variant)) => + write!(f, "unknown field type {}", variant), + SchemaError::UnknownAnyType(NotInSchema(variant)) => + write!(f, "unknown any pointer type {}", variant), + SchemaError::UnknownPointerType(NotInSchema(variant)) => + write!(f, "unknown unconstrained pointer type {}", variant), + SchemaError::UnknownScopeBinding(NotInSchema(variant)) => + write!(f, "unknown scope binding {}", variant), + SchemaError::UnexpectedNodeType => write!(f, "unexpected node type"), + SchemaError::InvalidBrandType => write!(f, "invalid brand type"), + } + } +} + +impl std::error::Error for SchemaError {} + +pub type Id = u64; + +/// Allows easily reading a schema from a set of nodes. +pub struct SchemaLoader { + nodes: HashMap, +} + +impl SchemaLoader { + pub fn new() -> Self { + Self { nodes: HashMap::new() } + } + + pub fn load(&mut self, node: &ReaderOf<'_, Node>) -> Result<()> { + let id = node.id(); + if self.nodes.contains_key(&id) { + return Err(SchemaError::DuplicateNode(id))? + } + + let node = UncheckedNode::new(node)?; + let _ = self.nodes.insert(id, node); + + Ok(()) + } + + pub fn files(&self) -> impl Iterator> + '_ { + self.nodes.values().filter_map(|n| FileSchema::from_node(n.get(), self)) + } + + pub fn get(&self, id: Id) -> Option> { + self.nodes.get(&id).map(UncheckedNode::get) + } + + pub fn schema<'a, T: Schema<'a>>(&'a self, id: Id) -> Option { + self.get(id).and_then(|n| T::from_node(n, self)) + } + + pub fn try_schema<'a, T: Schema<'a>>(&'a self, id: Id) -> Result { + let node = self.get(id).ok_or(SchemaError::MissingNode(id))?; + let schema = T::from_node(node, self).ok_or(SchemaError::UnexpectedNodeType)?; + Ok(schema) + } + + pub fn resolve_brand<'a>(&'a self, brand: &ReaderOf<'a, Brand>) -> Result> { + let scopes_list = brand.scopes().get(); + let scopes = { + let mut scopes = Vec::with_capacity(scopes_list.len() as usize); + for scope in scopes_list { + let scope_id = scope.scope_id(); + use schema_capnp::brand::scope::Which; + let branding = match scope.which().map_err(SchemaError::UnknownScopeBinding)? { + Which::Bind(bind) => { + let mut bindings = Vec::new(); + for (index, binding) in bind.into_iter().enumerate() { + use schema_capnp::brand::binding::Which; + let binding = match binding.which().map_err(SchemaError::UnknownScopeBinding)? { + Which::Type(ty) => { + let ty = ty.get(); + self.resolve_type(&ty)? + }, + Which::Unbound(()) => TypeKind::ScopeBound { + scope: scope_id, + index: index as u16, + }.into(), + }; + bindings.push(binding); + } + ScopeBranding::Bind(bindings) + }, + Which::Inherit(()) => ScopeBranding::Inherit, + }; + scopes.push((scope_id, branding)); + } + scopes.sort_by_key(|(id, _)| *id); + scopes + }; + Ok(Branding { scopes }) + } + + pub fn gather_node_parameters<'a>(&'a self, node: &ReaderOf<'a, Node>) -> Result>> { + let mut vec = VecDeque::new(); + let mut node = node.clone(); + while node.is_generic() { + let scope = node.id(); + for (idx, p) in node.parameters().into_iter().enumerate().rev() { + vec.push_front(Parameter { scope, index: idx as u16, name: p.name().get() }); + } + + let parent = node.scope_id(); + node = self.get(parent).ok_or(SchemaError::MissingNode(parent))?; + } + + Ok(vec) + } + + pub fn gather_node_bindings<'a>( + &'a self, + node: &ReaderOf<'a, Node>, + brand: &Branding<'a>, + ) -> Result>> { + let mut vec = VecDeque::new(); + let mut node = node.clone(); + while node.is_generic() { + let scope = node.id(); + let params = node.parameters().get(); + match brand.find(scope) { + Some(ScopeBranding::Inherit) => { + for (idx, _) in params.into_iter().enumerate().rev() { + vec.push_front(TypeKind::ScopeBound { scope, index: idx as u16 }.into()); + } + } + Some(ScopeBranding::Bind(bindings)) => { + assert_eq!(bindings.len(), params.len() as usize); + bindings.iter().for_each(|b| vec.push_front(b.clone())); + } + None => for _ in 0..params.len() { + // no binding was found, so we just push any pointer for each generic + vec.push_front(TypeKind::AnyPointer.into()) + } + } + + let parent = node.scope_id(); + node = self.get(parent).ok_or(SchemaError::MissingNode(parent))?; + } + + Ok(vec) + } + + pub fn resolve_type<'a>( + &'a self, + ty: &ReaderOf<'a, schema_capnp::Type>, + ) -> Result> { + self.resolve_type_inner(ty, 0) + } + + fn resolve_type_inner<'a>( + &'a self, + ty: &ReaderOf<'a, schema_capnp::Type>, + list_depth: u32, + ) -> Result> { + use schema_capnp::r#type::Which; + let kind = match ty.which().map_err(SchemaError::UnknownType)? { + Which::Void(()) => TypeKind::Void, + Which::Bool(()) => TypeKind::Bool, + Which::Int8(()) => TypeKind::Int8, + Which::Int16(()) => TypeKind::Int16, + Which::Int32(()) => TypeKind::Int32, + Which::Int64(()) => TypeKind::Int64, + Which::Uint8(()) => TypeKind::Uint8, + Which::Uint16(()) => TypeKind::Uint16, + Which::Uint32(()) => TypeKind::Uint32, + Which::Uint64(()) => TypeKind::Uint64, + Which::Float32(()) => TypeKind::Float32, + Which::Float64(()) => TypeKind::Float64, + Which::Text(()) => TypeKind::Text, + Which::Data(()) => TypeKind::Data, + Which::List(list) => { + let element_type = list.element_type().get(); + return self.resolve_type_inner(&element_type, list_depth + 1) + }, + Which::Enum(e) => { + let ty = self.try_schema(e.type_id())?; + let brand = self.resolve_brand(&e.brand().get())?; + TypeKind::Enum { schema: Box::new(ty), parameters: brand } + }, + Which::Struct(s) => { + let ty = self.try_schema(s.type_id())?; + let brand = self.resolve_brand(&s.brand().get())?; + TypeKind::Struct { schema: Box::new(ty), parameters: brand } + }, + Which::Interface(i) => { + let ty = self.try_schema(i.type_id())?; + let brand = self.resolve_brand(&i.brand().get())?; + TypeKind::Interface { schema: Box::new(ty), parameters: brand } + }, + Which::AnyPointer(any) => { + use schema_capnp::r#type::any_pointer::Which; + match any.which().map_err(SchemaError::UnknownPointerType)? { + Which::Unconstrained(unconstrained) => { + use schema_capnp::r#type::any_pointer::unconstrained::Which; + match unconstrained.which().map_err(SchemaError::UnknownPointerType)? { + Which::AnyKind(()) => TypeKind::AnyPointer, + Which::Struct(()) => TypeKind::AnyStruct, + Which::List(()) => TypeKind::AnyList, + Which::Capability(()) => TypeKind::AnyCapability, + } + }, + Which::Parameter(param) => TypeKind::ScopeBound { + scope: param.scope_id(), index: param.parameter_index(), + }, + Which::ImplicitMethodParameter(method_param) => + TypeKind::ImplicitMethodParameter { index: method_param.parameter_index() }, + } + } + }; + Ok(Type { list_depth, kind }) + } +} + +#[derive(Debug)] +pub struct Parameter<'a> { + pub scope: Id, + pub index: u16, + pub name: text::Reader<'a>, +} + +#[derive(Clone)] +pub enum ScopeBranding<'a> { + Inherit, + Bind(Vec>), +} + +#[derive(Clone)] +pub struct Branding<'a> { + scopes: Vec<(Id, ScopeBranding<'a>)>, +} + +impl<'a> Branding<'a> { + pub fn find(&self, scope: Id) -> Option<&ScopeBranding<'a>> { + let idx = self.scopes.binary_search_by(|(s, _)| s.cmp(&scope)).ok()?; + Some(&self.scopes[idx].1) + } +} + +pub struct NamedNestedItem<'a> { + pub name: text::Reader<'a>, + pub id: Id, + pub item: NestedItem<'a>, +} + +pub enum NestedItem<'a> { + Struct(StructSchema<'a>), + Enum(EnumSchema<'a>), + Interface(InterfaceSchema<'a>), + Const(ConstSchema<'a>), + Annotation(AnnotationSchema<'a>), +} + +pub trait Schema<'a>: Sized { + fn from_node(node: ReaderOf<'a, Node>, loader: &'a SchemaLoader) -> Option; + + fn node(&self) -> &ReaderOf<'a, Node>; + fn loader(&self) -> &'a SchemaLoader; + + fn nested_items(&self) -> impl Iterator>> + 'a { + let loader = self.loader(); + self.node().nested_nodes().into_iter().map(|node| { + let name = node.name().get(); + let id = node.id(); + let node = loader.get(id).ok_or(SchemaError::MissingNode(id))?; + let kind = match node.which() { + Ok(k) => k, + Err(err) => Err(SchemaError::UnknownNodeType(err))?, + }; + + macro_rules! ctor { + ($ty:ident, $info:expr) => { + $ty { node, info: $info, loader } + }; + } + + let item = match kind { + NodeKind::File(()) => return Err(SchemaError::InvalidNestedNode(id))?, + NodeKind::Struct(info) => NestedItem::Struct(ctor!(StructSchema, info)), + NodeKind::Enum(info) => NestedItem::Enum(ctor!(EnumSchema, info)), + NodeKind::Interface(info) => NestedItem::Interface(ctor!(InterfaceSchema, info)), + NodeKind::Const(info) => NestedItem::Const(ctor!(ConstSchema, info)), + NodeKind::Annotation(info) => NestedItem::Annotation(ctor!(AnnotationSchema, info)), + }; + + Ok(NamedNestedItem { name, id, item }) + }) + } + + /// Gather a list of all generic parameters in this node scope. + fn gather_parameters(&self) -> Result>> { + self.loader().gather_node_parameters(self.node()) + } + + /// Gather a list of all generic bindings with the given brand. + fn gather_bindings(&self, brand: &Branding<'a>) -> Result>> { + self.loader().gather_node_bindings(self.node(), brand) + } +} + +#[derive(Clone)] +pub struct Type<'a> { + pub list_depth: u32, + pub kind: TypeKind<'a>, +} + +impl<'a> From> for Type<'a> { + fn from(value: TypeKind<'a>) -> Self { + Type { list_depth: 0, kind: value } + } +} + +#[derive(Clone)] +pub enum TypeKind<'a> { + Void, + Bool, + Int8, + Int16, + Int32, + Int64, + Uint8, + Uint16, + Uint32, + Uint64, + Float32, + Float64, + Enum { + schema: Box>, + parameters: Branding<'a>, + }, + Data, + Text, + Struct { + schema: Box>, + parameters: Branding<'a>, + }, + Interface { + schema: Box>, + parameters: Branding<'a>, + }, + AnyPointer, + AnyStruct, + AnyList, + AnyCapability, + ScopeBound { + scope: Id, + index: u16, + }, + ImplicitMethodParameter { + index: u16, + }, +} + +impl Type<'_> { + pub fn is_list(&self) -> bool { + self.list_depth > 0 + } + + pub fn is_list_of_lists(&self) -> bool { + self.list_depth > 1 + } + + /// Returns whether a field of this type would be placed in the data section of a struct + pub fn is_data_field(&self) -> bool { + if self.list_depth != 0 { + return false + } + + use TypeKind::*; + matches!( + &self.kind, + Void | Bool | Int8 | Int16 | Int32 | Int64 | Uint8 | Uint16 | Uint32 | Uint64 | + Float32 | Float64 | Enum { .. } + ) + } + + pub fn is_ptr_field(&self) -> bool { + !self.is_data_field() + } +} + +pub struct FileSchema<'a> { + pub node: ReaderOf<'a, Node>, + loader: &'a SchemaLoader, +} + +impl<'a> Schema<'a> for FileSchema<'a> { + #[inline] + fn from_node( + node: ReaderOf<'a, Node>, + loader: &'a SchemaLoader, + ) -> Option { + node.file().is_set().then(|| Self { node, loader }) + } + + #[inline] + fn node(&self) -> &ReaderOf<'a, Node> { + &self.node + } + #[inline] + fn loader(&self) -> &'a SchemaLoader { + self.loader + } +} + +macro_rules! schema_type { + ($schema:ident, $ty:ident, $fn:ident) => { + #[derive(Clone)] + pub struct $schema<'a> { + pub node: ReaderOf<'a, Node>, + // TODO(someday): This is the same as node. Avoid doubling up? + pub info: ReaderOf<'a, $ty>, + #[allow(dead_code)] + loader: &'a SchemaLoader, + } + + impl<'a> Schema<'a> for $schema<'a> { + #[inline] + fn from_node( + node: ReaderOf<'a, Node>, + loader: &'a SchemaLoader, + ) -> Option { + node.$fn().get().map(|info| Self { node, info, loader }) + } + + #[inline] + fn node(&self) -> &ReaderOf<'a, Node> { + &self.node + } + #[inline] + fn loader(&self) -> &'a SchemaLoader { + self.loader + } + } + }; +} + +schema_type!(StructSchema, Struct, r#struct); + +impl<'a> StructSchema<'a> { + pub fn struct_size(&self) -> StructSize { + StructSize { data: self.info.data_word_count(), ptrs: self.info.pointer_count() } + } + + pub fn is_group(&self) -> bool { + self.info.is_group() + } + + pub fn fields(&self) -> impl Iterator> + '_ { + self.info.fields().into_iter().map(|info| FieldSchema { parent: self, info }) + } +} + +pub struct FieldSchema<'a, 'schema> { + pub parent: &'schema StructSchema<'a>, + pub info: ReaderOf<'a, Field>, +} + +impl<'a> FieldSchema<'a, '_> { + pub const NO_DISCRIMINANT: u16 = 0xffff; + + pub fn name(&self) -> text::Reader<'a> { + self.info.name().get() + } + + pub fn field_type(&self) -> Result> { + Ok(match self.info.which().map_err(SchemaError::UnknownFieldType)? { + schema_capnp::field::Which::Slot(slot) => { + let ty = slot.r#type().get(); + FieldType::Slot { + offset: slot.offset(), + field_type: self.parent.loader.resolve_type(&ty)?, + default_value: slot.had_explicit_default() + .then(|| slot.default_value().get_option()) + .flatten(), + } + }, + schema_capnp::field::Which::Group(group) => { + let ty = self.parent.loader.try_schema(group.type_id())?; + FieldType::Group(ty) + }, + }) + } + + pub fn discriminant(&self) -> Option { + let value = self.info.discriminant_value(); + if value == Self::NO_DISCRIMINANT { + None + } else { + Some(value) + } + } +} + +pub enum FieldType<'a> { + Slot { + offset: u32, + field_type: Type<'a>, + default_value: Option>, + }, + Group(StructSchema<'a>), +} + +schema_type!(EnumSchema, Enum, r#enum); + +impl<'a> EnumSchema<'a> { + pub fn enumerants(&self) -> impl Iterator> + 'a { + self.info.enumerants().into_iter().map(|e| e.name().get()) + } +} + +schema_type!(InterfaceSchema, Interface, interface); + +impl<'a> InterfaceSchema<'a> { + +} + +schema_type!(ConstSchema, Const, r#const); + +impl<'a> ConstSchema<'a> { + pub fn value_type(&self) -> Result> { + let ty = self.info.r#type().get(); + self.loader.resolve_type(&ty) + } + + pub fn value(&self) -> ReaderOf<'a, Value> { + self.info.value().get() + } +} + +schema_type!(AnnotationSchema, Annotation, annotation); \ No newline at end of file diff --git a/tests/src/gen/capnp/c++.capnp b/tests/src/gen/capnp/c++.capnp new file mode 100644 index 0000000..9eaff6d --- /dev/null +++ b/tests/src/gen/capnp/c++.capnp @@ -0,0 +1,48 @@ +# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors +# Licensed under the MIT License: +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +@0xbdf87d7bb8304e81; +$namespace("capnp::annotations"); + +annotation namespace(file): Text; +annotation name(field, enumerant, struct, enum, interface, method, param, group, union): Text; + +annotation allowCancellation(interface, method, file) :Void; +# Indicates that the server-side implementation of a method is allowed to be canceled when the +# client requests cancellation. Without this annotation, once a method call has been delivered to +# the server-side application code, any requests by the client to cancel it will be ignored, and +# the method will run to completion anyway. This applies even for local in-process calls. +# +# This behavior applies specifically to implementations that inherit from the C++ `Foo::Server` +# interface. The annotation won't affect DynamicCapability::Server implementations; they must set +# the cancellation mode at runtime. +# +# When applied to an interface rather than an individual method, the annotation applies to all +# methods in the interface. When applied to a file, it applies to all methods defined in the file. +# +# It's generally recommended that this annotation be applied to all methods. However, when doing +# so, it is important that the server implementation use cancellation-safe code. See: +# +# https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#cancellation +# +# If your code is not cancellation-safe, then allowing cancellation might give a malicious client +# an easy way to induce use-after-free or other bugs in your server, by requesting cancellation +# when not expected. diff --git a/tests/src/gen/capnp/stream.capnp b/tests/src/gen/capnp/stream.capnp new file mode 100644 index 0000000..bfcb72b --- /dev/null +++ b/tests/src/gen/capnp/stream.capnp @@ -0,0 +1,50 @@ +# Copyright (c) 2019 Cloudflare, Inc. and contributors +# Licensed under the MIT License: +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +@0x86c366a91393f3f8; +# Defines placeholder types used to provide backwards-compatibility while introducing streaming +# to the language. The goal is that old code generators that don't know about streaming can still +# generate code that functions, leaving it up to the application to implement flow control +# manually. + +$import "/capnp/c++.capnp".namespace("capnp"); + +struct StreamResult @0x995f9a3377c0b16e { + # Empty struct that serves as the return type for "streaming" methods. + # + # Defining a method like: + # + # write @0 (bytes :Data) -> stream; + # + # Is equivalent to: + # + # write @0 (bytes :Data) -> import "/capnp/stream.capnp".StreamResult; + # + # However, implementations that recognize streaming will elide the reference to StreamResult + # and instead give write() a different signature appropriate for streaming. + # + # Streaming methods do not return a result -- that is, they return Promise. This promise + # resolves not to indicate that the call was actually delivered, but instead to provide + # backpressure. When the previous call's promise resolves, it is time to make another call. On + # the client side, the RPC system will resolve promises immediately until an appropriate number + # of requests are in-flight, and then will delay promise resolution to apply back-pressure. + # On the server side, the RPC system will deliver one call at a time. +} diff --git a/tests/src/gen/capnp/test-import.capnp.rs b/tests/src/gen/capnp/test-import.capnp.rs index 711b9dd..2ccd745 100644 --- a/tests/src/gen/capnp/test-import.capnp.rs +++ b/tests/src/gen/capnp/test-import.capnp.rs @@ -100,7 +100,7 @@ impl TestImport { _p::Struct<__imports::capnp_test_capnp::TestAllTypes>, > { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; } impl<'p, T: _p::rpc::Table + 'p> test_import::Reader<'p, T> { diff --git a/tests/src/gen/capnp/test-import2.capnp.rs b/tests/src/gen/capnp/test-import2.capnp.rs index c95ef59..8522746 100644 --- a/tests/src/gen/capnp/test-import2.capnp.rs +++ b/tests/src/gen/capnp/test-import2.capnp.rs @@ -100,13 +100,13 @@ impl TestImport2 { _p::Struct<__imports::capnp_test_capnp::TestAllTypes>, > { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const BAR: _p::Descriptor< _p::Struct<__imports::capnp_test_import_capnp::TestImport>, > = _p::Descriptor::<_p::Struct<__imports::capnp_test_import_capnp::TestImport>> { slot: 1u32, - default: None, + default: ::core::option::Option::None, }; } impl<'p, T: _p::rpc::Table + 'p> test_import2::Reader<'p, T> { diff --git a/tests/src/gen/capnp/test.capnp b/tests/src/gen/capnp/test.capnp index 396bffa..69ccf88 100644 --- a/tests/src/gen/capnp/test.capnp +++ b/tests/src/gen/capnp/test.capnp @@ -21,6 +21,12 @@ @0xd508eebdc2dc42b8; +using Cxx = import "c++.capnp"; + +# Use a namespace likely to cause trouble if the generated code doesn't use fully-qualified +# names for stuff in the capnproto namespace. +$Cxx.namespace("capnproto_test::capnp::test"); + enum TestEnum { foo @0; bar @1; @@ -69,3 +75,966 @@ struct TestAllTypes { enumList @32 : List(TestEnum); interfaceList @33 : List(Void); # TODO } + +struct TestDefaults { + voidField @0 : Void = void; + boolField @1 : Bool = true; + int8Field @2 : Int8 = -123; + int16Field @3 : Int16 = -12345; + int32Field @4 : Int32 = -12345678; + int64Field @5 : Int64 = -123456789012345; + uInt8Field @6 : UInt8 = 234; + uInt16Field @7 : UInt16 = 45678; + uInt32Field @8 : UInt32 = 3456789012; + uInt64Field @9 : UInt64 = 12345678901234567890; + float32Field @10 : Float32 = 1234.5; + float64Field @11 : Float64 = -123e45; + textField @12 : Text = "foo"; + dataField @13 : Data = 0x"62 61 72"; # "bar" + structField @14 : TestAllTypes = ( + voidField = void, + boolField = true, + int8Field = -12, + int16Field = 3456, + int32Field = -78901234, + int64Field = 56789012345678, + uInt8Field = 90, + uInt16Field = 1234, + uInt32Field = 56789012, + uInt64Field = 345678901234567890, + float32Field = -1.25e-10, + float64Field = 345, + textField = "baz", + dataField = "qux", + structField = ( + textField = "nested", + structField = (textField = "really nested")), + enumField = baz, + # interfaceField can't have a default + + voidList = [void, void, void], + boolList = [false, true, false, true, true], + int8List = [12, -34, -0x80, 0x7f], + int16List = [1234, -5678, -0x8000, 0x7fff], + int32List = [12345678, -90123456, -0x80000000, 0x7fffffff], + int64List = [123456789012345, -678901234567890, -0x8000000000000000, 0x7fffffffffffffff], + uInt8List = [12, 34, 0, 0xff], + uInt16List = [1234, 5678, 0, 0xffff], + uInt32List = [12345678, 90123456, 0, 0xffffffff], + uInt64List = [123456789012345, 678901234567890, 0, 0xffffffffffffffff], + float32List = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37], + float64List = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], + textList = ["quux", "corge", "grault"], + dataList = ["garply", "waldo", "fred"], + structList = [ + (textField = "x " "structlist" + " 1"), + (textField = "x structlist 2"), + (textField = "x structlist 3")], + enumList = [qux, bar, grault] + # interfaceList can't have a default + ); + enumField @15 : TestEnum = corge; + interfaceField @16 : Void; # TODO + + voidList @17 : List(Void) = [void, void, void, void, void, void]; + boolList @18 : List(Bool) = [true, false, false, true]; + int8List @19 : List(Int8) = [111, -111]; + int16List @20 : List(Int16) = [11111, -11111]; + int32List @21 : List(Int32) = [111111111, -111111111]; + int64List @22 : List(Int64) = [1111111111111111111, -1111111111111111111]; + uInt8List @23 : List(UInt8) = [111, 222] ; + uInt16List @24 : List(UInt16) = [33333, 44444]; + uInt32List @25 : List(UInt32) = [3333333333]; + uInt64List @26 : List(UInt64) = [11111111111111111111]; + float32List @27 : List(Float32) = [5555.5, inf, -inf, nan]; + float64List @28 : List(Float64) = [7777.75, inf, -inf, nan]; + textList @29 : List(Text) = ["plugh", "xyzzy", "thud"]; + dataList @30 : List(Data) = ["oops", "exhausted", "rfc3092"]; + structList @31 : List(TestAllTypes) = [ + (textField = "structlist 1"), + (textField = "structlist 2"), + (textField = "structlist 3")]; + enumList @32 : List(TestEnum) = [foo, garply]; + interfaceList @33 : List(Void); # TODO +} + +struct TestAnyPointer { + anyPointerField @0 :AnyPointer; + + # Do not add any other fields here! Some tests rely on anyPointerField being the last pointer + # in the struct. +} + +struct TestAnyOthers { + anyStructField @0 :AnyStruct; + anyListField @1 :AnyList; + capabilityField @2 :Capability; +} + +struct TestOutOfOrder { + foo @3 :Text; + bar @2 :Text; + baz @8 :Text; + qux @0 :Text; + quux @6 :Text; + corge @4 :Text; + grault @1 :Text; + garply @7 :Text; + waldo @5 :Text; +} + +struct TestUnion { + union0 @0! :union { + # Pack union 0 under ideal conditions: there is no unused padding space prior to it. + u0f0s0 @4: Void; + u0f0s1 @5: Bool; + u0f0s8 @6: Int8; + u0f0s16 @7: Int16; + u0f0s32 @8: Int32; + u0f0s64 @9: Int64; + u0f0sp @10: Text; + + # Pack more stuff into union0 -- should go in same space. + u0f1s0 @11: Void; + u0f1s1 @12: Bool; + u0f1s8 @13: Int8; + u0f1s16 @14: Int16; + u0f1s32 @15: Int32; + u0f1s64 @16: Int64; + u0f1sp @17: Text; + } + + # Pack one bit in order to make pathological situation for union1. + bit0 @18: Bool; + + union1 @1! :union { + # Pack pathologically bad case. Each field takes up new space. + u1f0s0 @19: Void; + u1f0s1 @20: Bool; + u1f1s1 @21: Bool; + u1f0s8 @22: Int8; + u1f1s8 @23: Int8; + u1f0s16 @24: Int16; + u1f1s16 @25: Int16; + u1f0s32 @26: Int32; + u1f1s32 @27: Int32; + u1f0s64 @28: Int64; + u1f1s64 @29: Int64; + u1f0sp @30: Text; + u1f1sp @31: Text; + + # Pack more stuff into union1 -- each should go into the same space as corresponding u1f0s*. + u1f2s0 @32: Void; + u1f2s1 @33: Bool; + u1f2s8 @34: Int8; + u1f2s16 @35: Int16; + u1f2s32 @36: Int32; + u1f2s64 @37: Int64; + u1f2sp @38: Text; + } + + # Fill in the rest of that bitfield from earlier. + bit2 @39: Bool; + bit3 @40: Bool; + bit4 @41: Bool; + bit5 @42: Bool; + bit6 @43: Bool; + bit7 @44: Bool; + + # Interleave two unions to be really annoying. + # Also declare in reverse order to make sure union discriminant values are sorted by field number + # and not by declaration order. + union2 @2! :union { + u2f0s64 @54: Int64; + u2f0s32 @52: Int32; + u2f0s16 @50: Int16; + u2f0s8 @47: Int8; + u2f0s1 @45: Bool; + } + + union3 @3! :union { + u3f0s64 @55: Int64; + u3f0s32 @53: Int32; + u3f0s16 @51: Int16; + u3f0s8 @48: Int8; + u3f0s1 @46: Bool; + } + + byte0 @49: UInt8; +} + +struct TestUnnamedUnion { + before @0 :Text; + + union { + foo @1 :UInt16; + bar @3 :UInt32; + } + + middle @2 :UInt16; + + after @4 :Text; +} + +struct TestUnionInUnion { + # There is no reason to ever do this. + outer :union { + inner :union { + foo @0 :Int32; + bar @1 :Int32; + } + baz @2 :Int32; + } +} + +struct TestGroups { + groups :union { + foo :group { + corge @0 :Int32; + grault @2 :Int64; + garply @8 :Text; + } + bar :group { + corge @3 :Int32; + grault @4 :Text; + garply @5 :Int64; + } + baz :group { + corge @1 :Int32; + grault @6 :Text; + garply @7 :Text; + } + } +} + +struct TestInterleavedGroups { + group1 :group { + foo @0 :UInt32; + bar @2 :UInt64; + union { + qux @4 :UInt16; + corge :group { + grault @6 :UInt64; + garply @8 :UInt16; + plugh @14 :Text; + xyzzy @16 :Text; + } + + fred @12 :Text; + } + + waldo @10 :Text; + } + + group2 :group { + foo @1 :UInt32; + bar @3 :UInt64; + union { + qux @5 :UInt16; + corge :group { + grault @7 :UInt64; + garply @9 :UInt16; + plugh @15 :Text; + xyzzy @17 :Text; + } + + fred @13 :Text; + } + + waldo @11 :Text; + } +} + +struct TestUnionDefaults { + s16s8s64s8Set @0 :TestUnion = + (union0 = (u0f0s16 = 321), union1 = (u1f0s8 = 123), union2 = (u2f0s64 = 12345678901234567), + union3 = (u3f0s8 = 55)); + s0sps1s32Set @1 :TestUnion = + (union0 = (u0f1s0 = void), union1 = (u1f0sp = "foo"), union2 = (u2f0s1 = true), + union3 = (u3f0s32 = 12345678)); + + unnamed1 @2 :TestUnnamedUnion = (foo = 123); + unnamed2 @3 :TestUnnamedUnion = (bar = 321, before = "foo", after = "bar"); +} + +struct TestNestedTypes { + enum NestedEnum { + foo @0; + bar @1; + } + + struct NestedStruct { + enum NestedEnum { + baz @0; + qux @1; + quux @2; + } + + outerNestedEnum @0 :TestNestedTypes.NestedEnum = bar; + innerNestedEnum @1 :NestedEnum = quux; + } + + nestedStruct @0 :NestedStruct; + + outerNestedEnum @1 :NestedEnum = bar; + innerNestedEnum @2 :NestedStruct.NestedEnum = quux; +} + +struct TestUsing { + using OuterNestedEnum = TestNestedTypes.NestedEnum; + using TestNestedTypes.NestedStruct.NestedEnum; + + outerNestedEnum @1 :OuterNestedEnum = bar; + innerNestedEnum @0 :NestedEnum = quux; +} + +struct TestLists { + # Small structs, when encoded as list, will be encoded as primitive lists rather than struct + # lists, to save space. + struct Struct0 { f @0 :Void; } + struct Struct1 { f @0 :Bool; } + struct Struct8 { f @0 :UInt8; } + struct Struct16 { f @0 :UInt16; } + struct Struct32 { f @0 :UInt32; } + struct Struct64 { f @0 :UInt64; } + struct StructP { f @0 :Text; } + + # Versions of the above which cannot be encoded as primitive lists. + struct Struct0c { f @0 :Void; pad @1 :Text; } + struct Struct1c { f @0 :Bool; pad @1 :Text; } + struct Struct8c { f @0 :UInt8; pad @1 :Text; } + struct Struct16c { f @0 :UInt16; pad @1 :Text; } + struct Struct32c { f @0 :UInt32; pad @1 :Text; } + struct Struct64c { f @0 :UInt64; pad @1 :Text; } + struct StructPc { f @0 :Text; pad @1 :UInt64; } + + list0 @0 :List(Struct0); + list1 @1 :List(Struct1); + list8 @2 :List(Struct8); + list16 @3 :List(Struct16); + list32 @4 :List(Struct32); + list64 @5 :List(Struct64); + listP @6 :List(StructP); + + int32ListList @7 :List(List(Int32)); + textListList @8 :List(List(Text)); + structListList @9 :List(List(TestAllTypes)); +} + +struct TestFieldZeroIsBit { + bit @0 :Bool; + secondBit @1 :Bool = true; + thirdField @2 :UInt8 = 123; +} + +struct TestListDefaults { + lists @0 :TestLists = ( + list0 = [(f = void), (f = void)], + list1 = [(f = true), (f = false), (f = true), (f = true)], + list8 = [(f = 123), (f = 45)], + list16 = [(f = 12345), (f = 6789)], + list32 = [(f = 123456789), (f = 234567890)], + list64 = [(f = 1234567890123456), (f = 2345678901234567)], + listP = [(f = "foo"), (f = "bar")], + int32ListList = [[1, 2, 3], [4, 5], [12341234]], + textListList = [["foo", "bar"], ["baz"], ["qux", "corge"]], + structListList = [[(int32Field = 123), (int32Field = 456)], [(int32Field = 789)]]); +} + +struct TestLateUnion { + # Test what happens if the unions are not the first ordinals in the struct. At one point this + # was broken for the dynamic API. + + foo @0 :Int32; + bar @1 :Text; + baz @2 :Int16; + + theUnion @3! :union { + qux @4 :Text; + corge @5 :List(Int32); + grault @6 :Float32; + } + + anotherUnion @7! :union { + qux @8 :Text; + corge @9 :List(Int32); + grault @10 :Float32; + } +} + +struct TestOldVersion { + # A subset of TestNewVersion. + old1 @0 :Int64; + old2 @1 :Text; + old3 @2 :TestOldVersion; +} + +struct TestNewVersion { + # A superset of TestOldVersion. + old1 @0 :Int64; + old2 @1 :Text; + old3 @2 :TestNewVersion; + new1 @3 :Int64 = 987; + new2 @4 :Text = "baz"; +} + +struct TestOldUnionVersion { + union { + a @0 :Void; + b @1 :UInt64; + } +} + +struct TestNewUnionVersion { + union { + a :union { + a0 @0 :Void; + a1 @2 :UInt64; + } + b @1 :UInt64; + } +} + +struct TestStructUnion { + un @0! :union { + struct @1 :SomeStruct; + object @2 :TestAnyPointer; + } + + struct SomeStruct { + someText @0 :Text; + moreText @1 :Text; + } +} + +struct TestPrintInlineStructs { + someText @0 :Text; + + structList @1 :List(InlineStruct); + struct InlineStruct { + int32Field @0 :Int32; + textField @1 :Text; + } +} + +struct TestWholeFloatDefault { + # At one point, these failed to compile in C++ because it would produce literals like "123f", + # which is not valid; it needs to be "123.0f". + field @0 :Float32 = 123; + bigField @1 :Float32 = 2e30; + const constant :Float32 = 456; + const bigConstant :Float32 = 4e30; +} + +struct TestGenerics(Foo, Bar) { + foo @0 :Foo; + rev @1 :TestGenerics(Bar, Foo); + + union { + uv @2:Void; + ug :group { + ugfoo @3:Int32; + } + } + + list @4 :List(Inner); + # At one time this failed to compile with MSVC due to poor expression SFINAE support. + + struct Inner { + foo @0 :Foo; + bar @1 :Bar; + } + + struct Inner2(Baz) { + bar @0 :Bar; + baz @1 :Baz; + innerBound @2 :Inner; + innerUnbound @3 :TestGenerics.Inner; + + struct DeepNest(Qux) { + foo @0 :Foo; + bar @1 :Bar; + baz @2 :Baz; + qux @3 :Qux; + + interface DeepNestInterface(Quux) { + # At one time this failed to compile. + call @0 () -> (); + } + } + } + + interface Interface(Qux) { + call @0 Inner2(Text) -> (qux :Qux, gen :TestGenerics(TestAllTypes, TestAnyPointer)); + } + + annotation ann(struct) :Foo; + + using AliasFoo = Foo; + using AliasInner = Inner; + using AliasInner2 = Inner2; + using AliasInner2Text = Inner2(Text); + using AliasRev = TestGenerics(Bar, Foo); + + struct UseAliases { + foo @0 :AliasFoo; + inner @1 :AliasInner; + inner2 @2 :AliasInner2; + inner2Bind @3 :AliasInner2(Text); + inner2Text @4 :AliasInner2Text; + revFoo @5 :AliasRev.AliasFoo; + } +} + +struct BoxedText { text @0 :Text; } +using BrandedAlias = TestGenerics(BoxedText, Text); + +struct TestGenericsWrapper(Foo, Bar) { + value @0 :TestGenerics(Foo, Bar); +} + +struct TestGenericsWrapper2 { + value @0 :TestGenericsWrapper(Text, TestAllTypes); +} + +interface TestImplicitMethodParams { + call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U); +} + +interface TestImplicitMethodParamsInGeneric(V) { + call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U); +} + +struct TestGenericsUnion(Foo, Bar) { + # At one point this failed to compile. + + union { + foo @0 :Foo; + bar @1 :Bar; + } +} + +struct TestUseGenerics $TestGenerics(Text, Data).ann("foo") { + basic @0 :TestGenerics(TestAllTypes, TestAnyPointer); + inner @1 :TestGenerics(TestAllTypes, TestAnyPointer).Inner; + inner2 @2 :TestGenerics(TestAllTypes, TestAnyPointer).Inner2(Text); + unspecified @3 :TestGenerics; + unspecifiedInner @4 :TestGenerics.Inner2(Text); + wrapper @8 :TestGenericsWrapper(TestAllTypes, TestAnyPointer); + cap @18 :TestGenerics(TestInterface, Text); + genericCap @19 :TestGenerics(TestAllTypes, List(UInt32)).Interface(Data); + + default @5 :TestGenerics(TestAllTypes, Text) = + (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321)))); + defaultInner @6 :TestGenerics(TestAllTypes, Text).Inner = + (foo = (int16Field = 123), bar = "text"); + defaultUser @7 :TestUseGenerics = (basic = (foo = (int16Field = 123))); + defaultWrapper @9 :TestGenericsWrapper(Text, TestAllTypes) = + (value = (foo = "text", rev = (foo = (int16Field = 321)))); + defaultWrapper2 @10 :TestGenericsWrapper2 = + (value = (value = (foo = "text", rev = (foo = (int16Field = 321))))); + + aliasFoo @11 :TestGenerics(TestAllTypes, TestAnyPointer).AliasFoo = (int16Field = 123); + aliasInner @12 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner + = (foo = (int16Field = 123)); + aliasInner2 @13 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2 + = (innerBound = (foo = (int16Field = 123))); + aliasInner2Bind @14 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2(List(UInt32)) + = (baz = [12, 34], innerBound = (foo = (int16Field = 123))); + aliasInner2Text @15 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2Text + = (baz = "text", innerBound = (foo = (int16Field = 123))); + aliasRev @16 :TestGenerics(TestAnyPointer, Text).AliasRev.AliasFoo = "text"; + + useAliases @17 :TestGenerics(TestAllTypes, List(UInt32)).UseAliases = ( + foo = (int16Field = 123), + inner = (foo = (int16Field = 123)), + inner2 = (innerBound = (foo = (int16Field = 123))), + inner2Bind = (baz = "text", innerBound = (foo = (int16Field = 123))), + inner2Text = (baz = "text", innerBound = (foo = (int16Field = 123))), + revFoo = [12, 34, 56]); +} + +struct TestEmptyStruct {} + +struct TestConstants { + const voidConst :Void = void; + const boolConst :Bool = true; + const int8Const :Int8 = -123; + const int16Const :Int16 = -12345; + const int32Const :Int32 = -12345678; + const int64Const :Int64 = -123456789012345; + const uint8Const :UInt8 = 234; + const uint16Const :UInt16 = 45678; + const uint32Const :UInt32 = 3456789012; + const uint64Const :UInt64 = 12345678901234567890; + const float32Const :Float32 = 1234.5; + const float64Const :Float64 = -123e45; + const textConst :Text = "foo"; + const dataConst :Data = "bar"; + const structConst :TestAllTypes = ( + voidField = void, + boolField = true, + int8Field = -12, + int16Field = 3456, + int32Field = -78901234, + int64Field = 56789012345678, + uInt8Field = 90, + uInt16Field = 1234, + uInt32Field = 56789012, + uInt64Field = 345678901234567890, + float32Field = -1.25e-10, + float64Field = 345, + textField = "baz", + dataField = "qux", + structField = ( + textField = "nested", + structField = (textField = "really nested")), + enumField = baz, + # interfaceField can't have a default + + voidList = [void, void, void], + boolList = [false, true, false, true, true], + int8List = [12, -34, -0x80, 0x7f], + int16List = [1234, -5678, -0x8000, 0x7fff], + int32List = [12345678, -90123456, -0x80000000, 0x7fffffff], + int64List = [123456789012345, -678901234567890, -0x8000000000000000, 0x7fffffffffffffff], + uInt8List = [12, 34, 0, 0xff], + uInt16List = [1234, 5678, 0, 0xffff], + uInt32List = [12345678, 90123456, 0, 0xffffffff], + uInt64List = [123456789012345, 678901234567890, 0, 0xffffffffffffffff], + float32List = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37], + float64List = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], + textList = ["quux", "corge", "grault"], + dataList = ["garply", "waldo", "fred"], + structList = [ + (textField = "x " "structlist" + " 1"), + (textField = "x structlist 2"), + (textField = "x structlist 3")], + enumList = [qux, bar, grault] + # interfaceList can't have a default + ); + const enumConst :TestEnum = corge; + + const voidListConst :List(Void) = [void, void, void, void, void, void]; + const boolListConst :List(Bool) = [true, false, false, true]; + const int8ListConst :List(Int8) = [111, -111]; + const int16ListConst :List(Int16) = [11111, -11111]; + const int32ListConst :List(Int32) = [111111111, -111111111]; + const int64ListConst :List(Int64) = [1111111111111111111, -1111111111111111111]; + const uint8ListConst :List(UInt8) = [111, 222] ; + const uint16ListConst :List(UInt16) = [33333, 44444]; + const uint32ListConst :List(UInt32) = [3333333333]; + const uint64ListConst :List(UInt64) = [11111111111111111111]; + const float32ListConst :List(Float32) = [5555.5, inf, -inf, nan]; + const float64ListConst :List(Float64) = [7777.75, inf, -inf, nan]; + const textListConst :List(Text) = ["plugh", "xyzzy", "thud"]; + const dataListConst :List(Data) = ["oops", "exhausted", "rfc3092"]; + const structListConst :List(TestAllTypes) = [ + (textField = "structlist 1"), + (textField = "structlist 2"), + (textField = "structlist 3")]; + const enumListConst :List(TestEnum) = [foo, garply]; +} + +const globalInt :UInt32 = 12345; +const globalText :Text = "foobar"; +const globalStruct :TestAllTypes = (int32Field = 54321); +const globalPrintableStruct :TestPrintInlineStructs = (someText = "foo"); +const derivedConstant :TestAllTypes = ( + uInt32Field = .globalInt, + textField = TestConstants.textConst, + structField = TestConstants.structConst, + int16List = TestConstants.int16ListConst, + structList = TestConstants.structListConst); + +const genericConstant :TestGenerics(TestAllTypes, Text) = + (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321)))); + +const embeddedData :Data = embed "testdata/packed"; +const embeddedText :Text = embed "testdata/short.txt"; +const embeddedStruct :TestAllTypes = embed "testdata/binary"; + +const nonAsciiText :Text = "♫ é ✓"; + +const blockText :Text = + `foo bar baz + `"qux" `corge` 'grault' + "regular\"quoted\"line" + `garply\nwaldo\tfred\"plugh\"xyzzy\'thud + ; + +struct TestAnyPointerConstants { + anyKindAsStruct @0 :AnyPointer; + anyStructAsStruct @1 :AnyStruct; + anyKindAsList @2 :AnyPointer; + anyListAsList @3 :AnyList; +} + +const anyPointerConstants :TestAnyPointerConstants = ( + anyKindAsStruct = TestConstants.structConst, + anyStructAsStruct = TestConstants.structConst, + anyKindAsList = TestConstants.int32ListConst, + anyListAsList = TestConstants.int32ListConst, +); + +struct TestListOfAny { + capList @0 :List(Capability); + listList @1 :List(AnyList); +} + +interface TestInterface { + foo @0 (i :UInt32, j :Bool) -> (x :Text); + bar @1 () -> (); + baz @2 (s: TestAllTypes); +} + +interface TestExtends extends(TestInterface) { + qux @0 (); + corge @1 TestAllTypes -> (); + grault @2 () -> TestAllTypes; +} + +interface TestExtends2 extends(TestExtends) {} + +interface TestPipeline { + getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); + testPointers @1 (cap :TestInterface, obj :AnyPointer, list :List(TestInterface)) -> (); + getAnyCap @2 (n: UInt32, inCap :Capability) -> (s: Text, outBox :AnyBox); + + getCapPipelineOnly @3 () -> (outBox :Box); + # Never returns, but uses setPipeline() to make the pipeline work. + + struct Box { + cap @0 :TestInterface; + } + struct AnyBox { + cap @0 :Capability; + } +} + +interface TestCallOrder { + getCallSequence @0 (expected: UInt32) -> (n: UInt32); + # First call returns 0, next returns 1, ... + # + # The input `expected` is ignored but useful for disambiguating debug logs. +} + +interface TestTailCallee $Cxx.allowCancellation { + struct TailResult { + i @0 :UInt32; + t @1 :Text; + c @2 :TestCallOrder; + } + + foo @0 (i :Int32, t :Text) -> TailResult; +} + +interface TestTailCaller { + foo @0 (i :Int32, callee :TestTailCallee) -> TestTailCallee.TailResult; +} + +interface TestStreaming $Cxx.allowCancellation { + doStreamI @0 (i :UInt32) -> stream; + doStreamJ @1 (j :UInt32) -> stream; + finishStream @2 () -> (totalI :UInt32, totalJ :UInt32); + # Test streaming. finishStream() returns the totals of the values streamed to the other calls. +} + +interface TestHandle {} + +interface TestMoreStuff extends(TestCallOrder) { + # Catch-all type that contains lots of testing methods. + + callFoo @0 (cap :TestInterface) -> (s: Text); + # Call `cap.foo()`, check the result, and return "bar". + + callFooWhenResolved @1 (cap :TestInterface) -> (s: Text); + # Like callFoo but waits for `cap` to resolve first. + + neverReturn @2 (cap :TestInterface) -> (capCopy :TestInterface) $Cxx.allowCancellation; + # Doesn't return. You should cancel it. + + hold @3 (cap :TestInterface) -> (); + # Returns immediately but holds on to the capability. + + callHeld @4 () -> (s: Text); + # Calls the capability previously held using `hold` (and keeps holding it). + + getHeld @5 () -> (cap :TestInterface); + # Returns the capability previously held using `hold` (and keeps holding it). + + echo @6 (cap :TestCallOrder) -> (cap :TestCallOrder); + # Just returns the input cap. + + expectCancel @7 (cap :TestInterface) -> () $Cxx.allowCancellation; + # evalLater()-loops forever, holding `cap`. Must be canceled. + + methodWithDefaults @8 (a :Text, b :UInt32 = 123, c :Text = "foo") -> (d :Text, e :Text = "bar"); + + methodWithNullDefault @12 (a :Text, b :TestInterface = null); + + getHandle @9 () -> (handle :TestHandle); + # Get a new handle. Tests have an out-of-band way to check the current number of live handles, so + # this can be used to test garbage collection. + + getNull @10 () -> (nullCap :TestMoreStuff); + # Always returns a null capability. + + getEnormousString @11 () -> (str :Text); + # Attempts to return an 100MB string. Should always fail. + + writeToFd @13 (fdCap1 :TestInterface, fdCap2 :TestInterface) + -> (fdCap3 :TestInterface, secondFdPresent :Bool); + # Expects fdCap1 and fdCap2 wrap socket file descriptors. Writes "foo" to the first and "bar" to + # the second. Also creates a socketpair, writes "baz" to one end, and returns the other end. + + throwException @14 (); + throwRemoteException @15 (); +} + +interface TestMembrane { + makeThing @0 () -> (thing :Thing); + callPassThrough @1 (thing :Thing, tailCall :Bool) -> Result; + callIntercept @2 (thing :Thing, tailCall :Bool) -> Result; + loopback @3 (thing :Thing) -> (thing :Thing); + + waitForever @4 () $Cxx.allowCancellation; + + interface Thing { + passThrough @0 () -> Result; + intercept @1 () -> Result; + } + + struct Result { + text @0 :Text; + } +} + +struct TestContainMembrane { + cap @0 :TestMembrane.Thing; + list @1 :List(TestMembrane.Thing); +} + +struct TestTransferCap { + list @0 :List(Element); + struct Element { + text @0 :Text; + cap @1 :TestInterface; + } +} + +interface TestKeywordMethods { + delete @0 (); + class @1 (); + void @2 (); + return @3 (); +} + +interface TestAuthenticatedBootstrap(VatId) { + getCallerId @0 () -> (caller :VatId); +} + +struct TestSturdyRef { + hostId @0 :TestSturdyRefHostId; + objectId @1 :AnyPointer; +} + +struct TestSturdyRefHostId { + host @0 :Text; +} + +struct TestSturdyRefObjectId { + tag @0 :Tag; + enum Tag { + testInterface @0; + testExtends @1; + testPipeline @2; + testTailCallee @3; + testTailCaller @4; + testMoreStuff @5; + } +} + +struct TestProvisionId {} +struct TestRecipientId {} +struct TestThirdPartyCapId {} +struct TestJoinResult {} + +struct TestNameAnnotation $Cxx.name("RenamedStruct") { + union { + badFieldName @0 :Bool $Cxx.name("goodFieldName"); + bar @1 :Int8; + } + + enum BadlyNamedEnum $Cxx.name("RenamedEnum") { + foo @0; + bar @1; + baz @2 $Cxx.name("qux"); + } + + anotherBadFieldName @2 :BadlyNamedEnum $Cxx.name("anotherGoodFieldName"); + + struct NestedStruct $Cxx.name("RenamedNestedStruct") { + badNestedFieldName @0 :Bool $Cxx.name("goodNestedFieldName"); + anotherBadNestedFieldName @1 :NestedStruct $Cxx.name("anotherGoodNestedFieldName"); + + enum DeeplyNestedEnum $Cxx.name("RenamedDeeplyNestedEnum") { + quux @0; + corge @1; + grault @2 $Cxx.name("garply"); + } + } + + badlyNamedUnion :union $Cxx.name("renamedUnion") { + badlyNamedGroup :group $Cxx.name("renamedGroup") { + foo @3 :Void; + bar @4 :Void; + } + baz @5 :NestedStruct $Cxx.name("qux"); + } +} + +interface TestNameAnnotationInterface $Cxx.name("RenamedInterface") { + badlyNamedMethod @0 (badlyNamedParam :UInt8 $Cxx.name("renamedParam")) $Cxx.name("renamedMethod"); +} + +struct TestImpliedFirstField { + struct TextStruct { + text @0 :Text; + i @1 :UInt32 = 321; + } + + textStruct @0 :TextStruct = "foo"; + textStructList @1 :List(TextStruct); + + intGroup :group { + i @2 :UInt32; + str @3 :Text = "corge"; + } +} + +const testImpliedFirstField :TestImpliedFirstField = ( + textStruct = "bar", + textStructList = ["baz", (text = "qux", i = 123)], + intGroup = 123 +); + +struct TestCycleANoCaps { + foo @0 :TestCycleBNoCaps; +} + +struct TestCycleBNoCaps { + foo @0 :List(TestCycleANoCaps); + bar @1 :TestAllTypes; +} + +struct TestCycleAWithCaps { + foo @0 :TestCycleBWithCaps; +} + +struct TestCycleBWithCaps { + foo @0 :List(TestCycleAWithCaps); + bar @1 :TestInterface; +} diff --git a/tests/src/gen/capnp/test.capnp.rs b/tests/src/gen/capnp/test.capnp.rs index b95986e..d955b52 100644 --- a/tests/src/gen/capnp/test.capnp.rs +++ b/tests/src/gen/capnp/test.capnp.rs @@ -172,25 +172,25 @@ impl TestAllTypes { }; const FLOAT32_FIELD: _p::Descriptor = _p::Descriptor:: { slot: 8u32, - default: 0f32, + default: 0.0f32, }; const FLOAT64_FIELD: _p::Descriptor = _p::Descriptor:: { slot: 5u32, - default: 0f64, + default: 0.0f64, }; const TEXT_FIELD: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { slot: 0u32, - default: None, + default: ::core::option::Option::None, }; const DATA_FIELD: _p::Descriptor<_p::Data> = _p::Descriptor::<_p::Data> { slot: 1u32, - default: None, + default: ::core::option::Option::None, }; const STRUCT_FIELD: _p::Descriptor<_p::Struct> = _p::Descriptor::< _p::Struct, > { slot: 2u32, - default: None, + default: ::core::option::Option::None, }; const ENUM_FIELD: _p::Descriptor<_p::Enum> = _p::Descriptor::< _p::Enum, @@ -201,79 +201,79 @@ impl TestAllTypes { const INTERFACE_FIELD: _p::Descriptor<()> = (); const VOID_LIST: _p::Descriptor<_p::List<()>> = _p::Descriptor::<_p::List<()>> { slot: 3u32, - default: None, + default: ::core::option::Option::None, }; const BOOL_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 4u32, - default: None, + default: ::core::option::Option::None, }; const INT8_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 5u32, - default: None, + default: ::core::option::Option::None, }; const INT16_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 6u32, - default: None, + default: ::core::option::Option::None, }; const INT32_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 7u32, - default: None, + default: ::core::option::Option::None, }; const INT64_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 8u32, - default: None, + default: ::core::option::Option::None, }; const U_INT8_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 9u32, - default: None, + default: ::core::option::Option::None, }; const U_INT16_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 10u32, - default: None, + default: ::core::option::Option::None, }; const U_INT32_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 11u32, - default: None, + default: ::core::option::Option::None, }; const U_INT64_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 12u32, - default: None, + default: ::core::option::Option::None, }; const FLOAT32_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 13u32, - default: None, + default: ::core::option::Option::None, }; const FLOAT64_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { slot: 14u32, - default: None, + default: ::core::option::Option::None, }; const TEXT_LIST: _p::Descriptor<_p::List<_p::Text>> = _p::Descriptor::< _p::List<_p::Text>, > { slot: 15u32, - default: None, + default: ::core::option::Option::None, }; const DATA_LIST: _p::Descriptor<_p::List<_p::Data>> = _p::Descriptor::< _p::List<_p::Data>, > { slot: 16u32, - default: None, + default: ::core::option::Option::None, }; const STRUCT_LIST: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< _p::List<_p::Struct>, > { slot: 17u32, - default: None, + default: ::core::option::Option::None, }; const ENUM_LIST: _p::Descriptor<_p::List<_p::Enum>> = _p::Descriptor::< _p::List<_p::Enum>, > { slot: 18u32, - default: None, + default: ::core::option::Option::None, }; const INTERFACE_LIST: _p::Descriptor<_p::List<()>> = _p::Descriptor::<_p::List<()>> { slot: 19u32, - default: None, + default: ::core::option::Option::None, }; } impl<'p, T: _p::rpc::Table + 'p> test_all_types::Reader<'p, T> { @@ -1039,3 +1039,24963 @@ pub mod test_all_types { _p::StructBuilder<'a, T>, >; } +#[derive(Clone)] +pub struct TestDefaults(T); +impl _p::IntoFamily for TestDefaults { + type Family = TestDefaults; +} +impl _p::Capable for TestDefaults { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestDefaults>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestDefaults(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_defaults::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_defaults::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestDefaults(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_defaults::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_defaults::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_defaults::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_defaults::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_defaults::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_defaults::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_defaults::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_defaults::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestDefaults { + type Reader<'a, T: _p::rpc::Table> = test_defaults::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_defaults::Builder<'a, T>; +} +impl _p::ty::Struct for TestDefaults { + const SIZE: _p::StructSize = _p::StructSize { + data: 6u16, + ptrs: 20u16, + }; +} +impl TestDefaults { + const VOID_FIELD: _p::Descriptor<()> = (); + const BOOL_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: true, + }; + const INT8_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: -123i8, + }; + const INT16_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: -12345i16, + }; + const INT32_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: -12345678i32, + }; + const INT64_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: -123456789012345i64, + }; + const U_INT8_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 16u32, + default: 234u8, + }; + const U_INT16_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 9u32, + default: 45678u16, + }; + const U_INT32_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 5u32, + default: 3456789012u32, + }; + const U_INT64_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 3u32, + default: 12345678901234567890u64, + }; + const FLOAT32_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 8u32, + default: 1234.5f32, + }; + const FLOAT64_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 5u32, + default: -123000000000000000000000000000000000000000000000f64, + }; + const TEXT_FIELD: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::Some(_p::text::Reader::from_slice(b"foo\0")), + }; + const DATA_FIELD: _p::Descriptor<_p::Data> = _p::Descriptor::<_p::Data> { + slot: 1u32, + default: ::core::option::Option::Some(_p::data::Reader::from_slice(b"bar")), + }; + const STRUCT_FIELD: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 2u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([1u8, 244u8, 128u8, 13u8, 14u8, 16u8, 76u8, 251u8]), + _p::Word([78u8, 115u8, 232u8, 56u8, 166u8, 51u8, 0u8, 0u8]), + _p::Word([90u8, 0u8, 210u8, 4u8, 20u8, 136u8, 98u8, 3u8]), + _p::Word([210u8, 10u8, 111u8, 18u8, 33u8, 25u8, 204u8, 4u8]), + _p::Word([95u8, 112u8, 9u8, 175u8, 2u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 144u8, 117u8, 64u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 26u8, 0u8, 0u8, 0u8]), + _p::Word([76u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 24u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 41u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([37u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([53u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([65u8, 1u8, 0u8, 0u8, 52u8, 0u8, 0u8, 0u8]), + _p::Word([73u8, 1u8, 0u8, 0u8, 53u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 1u8, 0u8, 0u8, 119u8, 2u8, 0u8, 0u8]), + _p::Word([213u8, 2u8, 0u8, 0u8, 27u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 122u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([72u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([110u8, 101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 114u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([114u8, 101u8, 97u8, 108u8, 108u8, 121u8, 32u8, 110u8]), + _p::Word([101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8, 0u8]), + _p::Word([26u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 222u8, 128u8, 127u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 210u8, 233u8, 0u8, 128u8, 255u8, 127u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 64u8, 211u8, 160u8, 250u8]), + _p::Word([0u8, 0u8, 0u8, 128u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([46u8, 117u8, 19u8, 253u8, 138u8, 150u8, 253u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 128u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([12u8, 34u8, 0u8, 255u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 46u8, 22u8, 0u8, 0u8, 255u8, 255u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 192u8, 44u8, 95u8, 5u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([210u8, 138u8, 236u8, 2u8, 117u8, 105u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 56u8, 180u8, 150u8, 73u8]), + _p::Word([194u8, 189u8, 240u8, 124u8, 194u8, 189u8, 240u8, 252u8]), + _p::Word([234u8, 28u8, 8u8, 2u8, 234u8, 28u8, 8u8, 130u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([64u8, 222u8, 119u8, 131u8, 33u8, 18u8, 220u8, 66u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 127u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 255u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 0u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 128u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([99u8, 111u8, 114u8, 103u8, 101u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 114u8, 97u8, 117u8, 108u8, 116u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 97u8, 114u8, 112u8, 108u8, 121u8, 0u8, 0u8]), + _p::Word([119u8, 97u8, 108u8, 100u8, 111u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 114u8, 101u8, 100u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 49u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 50u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 51u8, 0u8, 0u8]), + _p::Word([3u8, 0u8, 1u8, 0u8, 6u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 6u16, + ptrs: 20u16, + }, + ) + }), + }; + const ENUM_FIELD: _p::Descriptor<_p::Enum> = _p::Descriptor::< + _p::Enum, + > { + slot: 18u32, + default: TestEnum::Corge, + }; + const INTERFACE_FIELD: _p::Descriptor<()> = (); + const VOID_LIST: _p::Descriptor<_p::List<()>> = _p::Descriptor::<_p::List<()>> { + slot: 3u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked(&[], 6u32, _p::ElementSize::Void) + }), + }; + const BOOL_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 4u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[_p::Word([9u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])], + 4u32, + _p::ElementSize::Bit, + ) + }), + }; + const INT8_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 5u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[_p::Word([111u8, 145u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])], + 2u32, + _p::ElementSize::Byte, + ) + }), + }; + const INT16_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 6u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[_p::Word([103u8, 43u8, 153u8, 212u8, 0u8, 0u8, 0u8, 0u8])], + 2u32, + _p::ElementSize::TwoBytes, + ) + }), + }; + const INT32_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 7u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[_p::Word([199u8, 107u8, 159u8, 6u8, 57u8, 148u8, 96u8, 249u8])], + 2u32, + _p::ElementSize::FourBytes, + ) + }), + }; + const INT64_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 8u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[ + _p::Word([199u8, 113u8, 196u8, 43u8, 171u8, 117u8, 107u8, 15u8]), + _p::Word([57u8, 142u8, 59u8, 212u8, 84u8, 138u8, 148u8, 240u8]), + ], + 2u32, + _p::ElementSize::EightBytes, + ) + }), + }; + const U_INT8_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 9u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[_p::Word([111u8, 222u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])], + 2u32, + _p::ElementSize::Byte, + ) + }), + }; + const U_INT16_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 10u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[_p::Word([53u8, 130u8, 156u8, 173u8, 0u8, 0u8, 0u8, 0u8])], + 2u32, + _p::ElementSize::TwoBytes, + ) + }), + }; + const U_INT32_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 11u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[_p::Word([85u8, 161u8, 174u8, 198u8, 0u8, 0u8, 0u8, 0u8])], + 1u32, + _p::ElementSize::FourBytes, + ) + }), + }; + const U_INT64_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 12u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[_p::Word([199u8, 113u8, 172u8, 181u8, 175u8, 152u8, 50u8, 154u8])], + 1u32, + _p::ElementSize::EightBytes, + ) + }), + }; + const FLOAT32_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 13u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[ + _p::Word([0u8, 156u8, 173u8, 69u8, 0u8, 0u8, 128u8, 127u8]), + _p::Word([0u8, 0u8, 128u8, 255u8, 0u8, 0u8, 192u8, 127u8]), + ], + 4u32, + _p::ElementSize::FourBytes, + ) + }), + }; + const FLOAT64_LIST: _p::Descriptor<_p::List> = _p::Descriptor::<_p::List> { + slot: 14u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 192u8, 97u8, 190u8, 64u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 240u8, 127u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 240u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 248u8, 127u8]), + ], + 4u32, + _p::ElementSize::EightBytes, + ) + }), + }; + const TEXT_LIST: _p::Descriptor<_p::List<_p::Text>> = _p::Descriptor::< + _p::List<_p::Text>, + > { + slot: 15u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[ + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([112u8, 108u8, 117u8, 103u8, 104u8, 0u8, 0u8, 0u8]), + _p::Word([120u8, 121u8, 122u8, 122u8, 121u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 104u8, 117u8, 100u8, 0u8, 0u8, 0u8, 0u8]), + ], + 3u32, + _p::ElementSize::Pointer, + ) + }), + }; + const DATA_LIST: _p::Descriptor<_p::List<_p::Data>> = _p::Descriptor::< + _p::List<_p::Data>, + > { + slot: 16u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[ + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 74u8, 0u8, 0u8, 0u8]), + _p::Word([13u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([111u8, 111u8, 112u8, 115u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([101u8, 120u8, 104u8, 97u8, 117u8, 115u8, 116u8, 101u8]), + _p::Word([100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([114u8, 102u8, 99u8, 51u8, 48u8, 57u8, 50u8, 0u8]), + ], + 3u32, + _p::ElementSize::Pointer, + ) + }), + }; + const STRUCT_LIST: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 17u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[ + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 49u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 50u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 51u8, 0u8, 0u8, 0u8, 0u8]), + ], + 3u32, + _p::ElementSize::InlineComposite(_p::StructSize { + data: 6u16, + ptrs: 20u16, + }), + ) + }), + }; + const ENUM_LIST: _p::Descriptor<_p::List<_p::Enum>> = _p::Descriptor::< + _p::List<_p::Enum>, + > { + slot: 18u32, + default: ::core::option::Option::Some(unsafe { + _p::ListReader::slice_unchecked( + &[_p::Word([0u8, 0u8, 7u8, 0u8, 0u8, 0u8, 0u8, 0u8])], + 2u32, + _p::ElementSize::TwoBytes, + ) + }), + }; + const INTERFACE_LIST: _p::Descriptor<_p::List<()>> = _p::Descriptor::<_p::List<()>> { + slot: 19u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_defaults::Reader<'p, T> { + #[inline] + pub fn void_field(&self) -> _p::Accessor<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::accessor(&self.0, &TestDefaults::VOID_FIELD) + } + } + #[inline] + pub fn bool_field(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { + ::accessor(&self.0, &TestDefaults::BOOL_FIELD) + } + } + #[inline] + pub fn int8_field(&self) -> _p::Accessor<'_, 'p, T, i8> { + unsafe { + ::accessor(&self.0, &TestDefaults::INT8_FIELD) + } + } + #[inline] + pub fn int16_field(&self) -> _p::Accessor<'_, 'p, T, i16> { + unsafe { + ::accessor(&self.0, &TestDefaults::INT16_FIELD) + } + } + #[inline] + pub fn int32_field(&self) -> _p::Accessor<'_, 'p, T, i32> { + unsafe { + ::accessor(&self.0, &TestDefaults::INT32_FIELD) + } + } + #[inline] + pub fn int64_field(&self) -> _p::Accessor<'_, 'p, T, i64> { + unsafe { + ::accessor(&self.0, &TestDefaults::INT64_FIELD) + } + } + #[inline] + pub fn u_int8_field(&self) -> _p::Accessor<'_, 'p, T, u8> { + unsafe { + ::accessor(&self.0, &TestDefaults::U_INT8_FIELD) + } + } + #[inline] + pub fn u_int16_field(&self) -> _p::Accessor<'_, 'p, T, u16> { + unsafe { + ::accessor( + &self.0, + &TestDefaults::U_INT16_FIELD, + ) + } + } + #[inline] + pub fn u_int32_field(&self) -> _p::Accessor<'_, 'p, T, u32> { + unsafe { + ::accessor( + &self.0, + &TestDefaults::U_INT32_FIELD, + ) + } + } + #[inline] + pub fn u_int64_field(&self) -> _p::Accessor<'_, 'p, T, u64> { + unsafe { + ::accessor( + &self.0, + &TestDefaults::U_INT64_FIELD, + ) + } + } + #[inline] + pub fn float32_field(&self) -> _p::Accessor<'_, 'p, T, f32> { + unsafe { + ::accessor( + &self.0, + &TestDefaults::FLOAT32_FIELD, + ) + } + } + #[inline] + pub fn float64_field(&self) -> _p::Accessor<'_, 'p, T, f64> { + unsafe { + ::accessor( + &self.0, + &TestDefaults::FLOAT64_FIELD, + ) + } + } + #[inline] + pub fn text_field(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &TestDefaults::TEXT_FIELD, + ) + } + } + #[inline] + pub fn data_field(&self) -> _p::Accessor<'_, 'p, T, _p::Data> { + unsafe { + <_p::Data as _p::field::FieldType>::accessor( + &self.0, + &TestDefaults::DATA_FIELD, + ) + } + } + #[inline] + pub fn struct_field(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestAllTypes, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::STRUCT_FIELD) + } + } + #[inline] + pub fn enum_field(&self) -> _p::Accessor<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + TestEnum, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::ENUM_FIELD) + } + } + #[inline] + pub fn interface_field(&self) -> _p::Accessor<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::accessor( + &self.0, + &TestDefaults::INTERFACE_FIELD, + ) + } + } + #[inline] + pub fn void_list(&self) -> _p::Accessor<'_, 'p, T, _p::List<()>> { + unsafe { + <_p::List< + (), + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::VOID_LIST) + } + } + #[inline] + pub fn bool_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + bool, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::BOOL_LIST) + } + } + #[inline] + pub fn int8_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i8, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::INT8_LIST) + } + } + #[inline] + pub fn int16_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i16, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::INT16_LIST) + } + } + #[inline] + pub fn int32_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i32, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::INT32_LIST) + } + } + #[inline] + pub fn int64_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i64, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::INT64_LIST) + } + } + #[inline] + pub fn u_int8_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + u8, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::U_INT8_LIST) + } + } + #[inline] + pub fn u_int16_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + u16, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::U_INT16_LIST) + } + } + #[inline] + pub fn u_int32_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + u32, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::U_INT32_LIST) + } + } + #[inline] + pub fn u_int64_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + u64, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::U_INT64_LIST) + } + } + #[inline] + pub fn float32_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + f32, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::FLOAT32_LIST) + } + } + #[inline] + pub fn float64_list(&self) -> _p::Accessor<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + f64, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::FLOAT64_LIST) + } + } + #[inline] + pub fn text_list(&self) -> _p::Accessor<'_, 'p, T, _p::List<_p::Text>> { + unsafe { + <_p::List< + _p::Text, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::TEXT_LIST) + } + } + #[inline] + pub fn data_list(&self) -> _p::Accessor<'_, 'p, T, _p::List<_p::Data>> { + unsafe { + <_p::List< + _p::Data, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::DATA_LIST) + } + } + #[inline] + pub fn struct_list( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::STRUCT_LIST) + } + } + #[inline] + pub fn enum_list(&self) -> _p::Accessor<'_, 'p, T, _p::List<_p::Enum>> { + unsafe { + <_p::List< + _p::Enum, + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::ENUM_LIST) + } + } + #[inline] + pub fn interface_list(&self) -> _p::Accessor<'_, 'p, T, _p::List<()>> { + unsafe { + <_p::List< + (), + > as _p::field::FieldType>::accessor(&self.0, &TestDefaults::INTERFACE_LIST) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_defaults::Builder<'p, T> { + #[inline] + pub fn void_field(&mut self) -> _p::AccessorMut<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::VOID_FIELD, + ) + } + } + #[inline] + pub fn bool_field(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::BOOL_FIELD, + ) + } + } + #[inline] + pub fn int8_field(&mut self) -> _p::AccessorMut<'_, 'p, T, i8> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::INT8_FIELD, + ) + } + } + #[inline] + pub fn int16_field(&mut self) -> _p::AccessorMut<'_, 'p, T, i16> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::INT16_FIELD, + ) + } + } + #[inline] + pub fn int32_field(&mut self) -> _p::AccessorMut<'_, 'p, T, i32> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::INT32_FIELD, + ) + } + } + #[inline] + pub fn int64_field(&mut self) -> _p::AccessorMut<'_, 'p, T, i64> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::INT64_FIELD, + ) + } + } + #[inline] + pub fn u_int8_field(&mut self) -> _p::AccessorMut<'_, 'p, T, u8> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::U_INT8_FIELD, + ) + } + } + #[inline] + pub fn u_int16_field(&mut self) -> _p::AccessorMut<'_, 'p, T, u16> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::U_INT16_FIELD, + ) + } + } + #[inline] + pub fn u_int32_field(&mut self) -> _p::AccessorMut<'_, 'p, T, u32> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::U_INT32_FIELD, + ) + } + } + #[inline] + pub fn u_int64_field(&mut self) -> _p::AccessorMut<'_, 'p, T, u64> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::U_INT64_FIELD, + ) + } + } + #[inline] + pub fn float32_field(&mut self) -> _p::AccessorMut<'_, 'p, T, f32> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::FLOAT32_FIELD, + ) + } + } + #[inline] + pub fn float64_field(&mut self) -> _p::AccessorMut<'_, 'p, T, f64> { + unsafe { + ::accessor( + &mut self.0, + &TestDefaults::FLOAT64_FIELD, + ) + } + } + #[inline] + pub fn text_field(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::TEXT_FIELD, + ) + } + } + #[inline] + pub fn data_field(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Data> { + unsafe { + <_p::Data as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::DATA_FIELD, + ) + } + } + #[inline] + pub fn struct_field( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestAllTypes, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::STRUCT_FIELD, + ) + } + } + #[inline] + pub fn enum_field(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + TestEnum, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::ENUM_FIELD) + } + } + #[inline] + pub fn interface_field(&mut self) -> _p::AccessorMut<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::INTERFACE_FIELD, + ) + } + } + #[inline] + pub fn void_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List<()>> { + unsafe { + <_p::List< + (), + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::VOID_LIST) + } + } + #[inline] + pub fn bool_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + bool, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::BOOL_LIST) + } + } + #[inline] + pub fn int8_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i8, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::INT8_LIST) + } + } + #[inline] + pub fn int16_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i16, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::INT16_LIST) + } + } + #[inline] + pub fn int32_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i32, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::INT32_LIST) + } + } + #[inline] + pub fn int64_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i64, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::INT64_LIST) + } + } + #[inline] + pub fn u_int8_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + u8, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::U_INT8_LIST) + } + } + #[inline] + pub fn u_int16_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + u16, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::U_INT16_LIST, + ) + } + } + #[inline] + pub fn u_int32_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + u32, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::U_INT32_LIST, + ) + } + } + #[inline] + pub fn u_int64_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + u64, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::U_INT64_LIST, + ) + } + } + #[inline] + pub fn float32_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + f32, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::FLOAT32_LIST, + ) + } + } + #[inline] + pub fn float64_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + f64, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::FLOAT64_LIST, + ) + } + } + #[inline] + pub fn text_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Text>> { + unsafe { + <_p::List< + _p::Text, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::TEXT_LIST) + } + } + #[inline] + pub fn data_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Data>> { + unsafe { + <_p::List< + _p::Data, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::DATA_LIST) + } + } + #[inline] + pub fn struct_list( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::STRUCT_LIST) + } + } + #[inline] + pub fn enum_list( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Enum>> { + unsafe { + <_p::List< + _p::Enum, + > as _p::field::FieldType>::accessor(&mut self.0, &TestDefaults::ENUM_LIST) + } + } + #[inline] + pub fn interface_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List<()>> { + unsafe { + <_p::List< + (), + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestDefaults::INTERFACE_LIST, + ) + } + } + #[inline] + pub fn into_text_field(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + self.0, + &TestDefaults::TEXT_FIELD, + ) + } + } + #[inline] + pub fn into_data_field(self) -> _p::AccessorOwned<'p, T, _p::Data> { + unsafe { + <_p::Data as _p::field::FieldType>::accessor( + self.0, + &TestDefaults::DATA_FIELD, + ) + } + } + #[inline] + pub fn into_struct_field( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestAllTypes, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::STRUCT_FIELD) + } + } + #[inline] + pub fn into_void_list(self) -> _p::AccessorOwned<'p, T, _p::List<()>> { + unsafe { + <_p::List< + (), + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::VOID_LIST) + } + } + #[inline] + pub fn into_bool_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + bool, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::BOOL_LIST) + } + } + #[inline] + pub fn into_int8_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + i8, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::INT8_LIST) + } + } + #[inline] + pub fn into_int16_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + i16, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::INT16_LIST) + } + } + #[inline] + pub fn into_int32_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + i32, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::INT32_LIST) + } + } + #[inline] + pub fn into_int64_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + i64, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::INT64_LIST) + } + } + #[inline] + pub fn into_u_int8_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + u8, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::U_INT8_LIST) + } + } + #[inline] + pub fn into_u_int16_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + u16, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::U_INT16_LIST) + } + } + #[inline] + pub fn into_u_int32_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + u32, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::U_INT32_LIST) + } + } + #[inline] + pub fn into_u_int64_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + u64, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::U_INT64_LIST) + } + } + #[inline] + pub fn into_float32_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + f32, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::FLOAT32_LIST) + } + } + #[inline] + pub fn into_float64_list(self) -> _p::AccessorOwned<'p, T, _p::List> { + unsafe { + <_p::List< + f64, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::FLOAT64_LIST) + } + } + #[inline] + pub fn into_text_list(self) -> _p::AccessorOwned<'p, T, _p::List<_p::Text>> { + unsafe { + <_p::List< + _p::Text, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::TEXT_LIST) + } + } + #[inline] + pub fn into_data_list(self) -> _p::AccessorOwned<'p, T, _p::List<_p::Data>> { + unsafe { + <_p::List< + _p::Data, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::DATA_LIST) + } + } + #[inline] + pub fn into_struct_list( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::STRUCT_LIST) + } + } + #[inline] + pub fn into_enum_list( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Enum>> { + unsafe { + <_p::List< + _p::Enum, + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::ENUM_LIST) + } + } + #[inline] + pub fn into_interface_list(self) -> _p::AccessorOwned<'p, T, _p::List<()>> { + unsafe { + <_p::List< + (), + > as _p::field::FieldType>::accessor(self.0, &TestDefaults::INTERFACE_LIST) + } + } +} +pub mod test_defaults { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestDefaults< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestDefaults< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestAnyPointer(T); +impl _p::IntoFamily for TestAnyPointer { + type Family = TestAnyPointer; +} +impl _p::Capable for TestAnyPointer { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestAnyPointer>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestAnyPointer(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_any_pointer::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_any_pointer::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestAnyPointer(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_any_pointer::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_any_pointer::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_any_pointer::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_any_pointer::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_any_pointer::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_any_pointer::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_any_pointer::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_any_pointer::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestAnyPointer { + type Reader<'a, T: _p::rpc::Table> = test_any_pointer::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_any_pointer::Builder<'a, T>; +} +impl _p::ty::Struct for TestAnyPointer { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; +} +impl TestAnyPointer { + const ANY_POINTER_FIELD: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_any_pointer::Reader<'p, T> { + #[inline] + pub fn any_pointer_field(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &TestAnyPointer::ANY_POINTER_FIELD, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_any_pointer::Builder<'p, T> { + #[inline] + pub fn any_pointer_field(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &TestAnyPointer::ANY_POINTER_FIELD, + ) + } + } + #[inline] + pub fn into_any_pointer_field(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &TestAnyPointer::ANY_POINTER_FIELD, + ) + } + } +} +pub mod test_any_pointer { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestAnyPointer< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestAnyPointer< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestAnyOthers(T); +impl _p::IntoFamily for TestAnyOthers { + type Family = TestAnyOthers; +} +impl _p::Capable for TestAnyOthers { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestAnyOthers>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestAnyOthers(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_any_others::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_any_others::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestAnyOthers(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_any_others::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_any_others::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_any_others::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_any_others::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_any_others::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_any_others::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_any_others::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_any_others::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestAnyOthers { + type Reader<'a, T: _p::rpc::Table> = test_any_others::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_any_others::Builder<'a, T>; +} +impl _p::ty::Struct for TestAnyOthers { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 3u16, + }; +} +impl TestAnyOthers { + const ANY_STRUCT_FIELD: _p::Descriptor<_p::AnyStruct> = _p::Descriptor::< + _p::AnyStruct, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; + const ANY_LIST_FIELD: _p::Descriptor<_p::AnyList> = _p::Descriptor::<_p::AnyList> { + slot: 1u32, + default: ::core::option::Option::None, + }; + const CAPABILITY_FIELD: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 2u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_any_others::Reader<'p, T> { + #[inline] + pub fn any_struct_field(&self) -> _p::Accessor<'_, 'p, T, _p::AnyStruct> { + unsafe { + <_p::AnyStruct as _p::field::FieldType>::accessor( + &self.0, + &TestAnyOthers::ANY_STRUCT_FIELD, + ) + } + } + #[inline] + pub fn any_list_field(&self) -> _p::Accessor<'_, 'p, T, _p::AnyList> { + unsafe { + <_p::AnyList as _p::field::FieldType>::accessor( + &self.0, + &TestAnyOthers::ANY_LIST_FIELD, + ) + } + } + #[inline] + pub fn capability_field(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &TestAnyOthers::CAPABILITY_FIELD, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_any_others::Builder<'p, T> { + #[inline] + pub fn any_struct_field(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyStruct> { + unsafe { + <_p::AnyStruct as _p::field::FieldType>::accessor( + &mut self.0, + &TestAnyOthers::ANY_STRUCT_FIELD, + ) + } + } + #[inline] + pub fn any_list_field(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyList> { + unsafe { + <_p::AnyList as _p::field::FieldType>::accessor( + &mut self.0, + &TestAnyOthers::ANY_LIST_FIELD, + ) + } + } + #[inline] + pub fn capability_field(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &TestAnyOthers::CAPABILITY_FIELD, + ) + } + } + #[inline] + pub fn into_any_struct_field(self) -> _p::AccessorOwned<'p, T, _p::AnyStruct> { + unsafe { + <_p::AnyStruct as _p::field::FieldType>::accessor( + self.0, + &TestAnyOthers::ANY_STRUCT_FIELD, + ) + } + } + #[inline] + pub fn into_any_list_field(self) -> _p::AccessorOwned<'p, T, _p::AnyList> { + unsafe { + <_p::AnyList as _p::field::FieldType>::accessor( + self.0, + &TestAnyOthers::ANY_LIST_FIELD, + ) + } + } + #[inline] + pub fn into_capability_field(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &TestAnyOthers::CAPABILITY_FIELD, + ) + } + } +} +pub mod test_any_others { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestAnyOthers< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestAnyOthers< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestOutOfOrder(T); +impl _p::IntoFamily for TestOutOfOrder { + type Family = TestOutOfOrder; +} +impl _p::Capable for TestOutOfOrder { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestOutOfOrder>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestOutOfOrder(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_out_of_order::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_out_of_order::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestOutOfOrder(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_out_of_order::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_out_of_order::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_out_of_order::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_out_of_order::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_out_of_order::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_out_of_order::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_out_of_order::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_out_of_order::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestOutOfOrder { + type Reader<'a, T: _p::rpc::Table> = test_out_of_order::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_out_of_order::Builder<'a, T>; +} +impl _p::ty::Struct for TestOutOfOrder { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 9u16, + }; +} +impl TestOutOfOrder { + const QUX: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const GRAULT: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 1u32, + default: ::core::option::Option::None, + }; + const BAR: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 2u32, + default: ::core::option::Option::None, + }; + const FOO: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 3u32, + default: ::core::option::Option::None, + }; + const CORGE: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 4u32, + default: ::core::option::Option::None, + }; + const WALDO: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 5u32, + default: ::core::option::Option::None, + }; + const QUUX: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 6u32, + default: ::core::option::Option::None, + }; + const GARPLY: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 7u32, + default: ::core::option::Option::None, + }; + const BAZ: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 8u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_out_of_order::Reader<'p, T> { + #[inline] + pub fn qux(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestOutOfOrder::QUX) + } + } + #[inline] + pub fn grault(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &TestOutOfOrder::GRAULT, + ) + } + } + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestOutOfOrder::BAR) + } + } + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestOutOfOrder::FOO) + } + } + #[inline] + pub fn corge(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestOutOfOrder::CORGE) + } + } + #[inline] + pub fn waldo(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestOutOfOrder::WALDO) + } + } + #[inline] + pub fn quux(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestOutOfOrder::QUUX) + } + } + #[inline] + pub fn garply(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &TestOutOfOrder::GARPLY, + ) + } + } + #[inline] + pub fn baz(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestOutOfOrder::BAZ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_out_of_order::Builder<'p, T> { + #[inline] + pub fn qux(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOutOfOrder::QUX, + ) + } + } + #[inline] + pub fn grault(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOutOfOrder::GRAULT, + ) + } + } + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOutOfOrder::BAR, + ) + } + } + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOutOfOrder::FOO, + ) + } + } + #[inline] + pub fn corge(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOutOfOrder::CORGE, + ) + } + } + #[inline] + pub fn waldo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOutOfOrder::WALDO, + ) + } + } + #[inline] + pub fn quux(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOutOfOrder::QUUX, + ) + } + } + #[inline] + pub fn garply(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOutOfOrder::GARPLY, + ) + } + } + #[inline] + pub fn baz(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOutOfOrder::BAZ, + ) + } + } + #[inline] + pub fn into_qux(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOutOfOrder::QUX) + } + } + #[inline] + pub fn into_grault(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOutOfOrder::GRAULT) + } + } + #[inline] + pub fn into_bar(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOutOfOrder::BAR) + } + } + #[inline] + pub fn into_foo(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOutOfOrder::FOO) + } + } + #[inline] + pub fn into_corge(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOutOfOrder::CORGE) + } + } + #[inline] + pub fn into_waldo(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOutOfOrder::WALDO) + } + } + #[inline] + pub fn into_quux(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOutOfOrder::QUUX) + } + } + #[inline] + pub fn into_garply(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOutOfOrder::GARPLY) + } + } + #[inline] + pub fn into_baz(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOutOfOrder::BAZ) + } + } +} +pub mod test_out_of_order { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestOutOfOrder< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestOutOfOrder< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestUnion(T); +impl _p::IntoFamily for TestUnion { + type Family = TestUnion; +} +impl _p::Capable for TestUnion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestUnion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestUnion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_union::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_union::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestUnion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_union::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_union::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_union::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_union::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_union::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_union::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_union::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_union::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestUnion { + type Reader<'a, T: _p::rpc::Table> = test_union::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_union::Builder<'a, T>; +} +impl _p::ty::Struct for TestUnion { + const SIZE: _p::StructSize = _p::StructSize { + data: 8u16, + ptrs: 2u16, + }; +} +impl TestUnion { + const UNION0: _p::Descriptor<_p::Group> = (); + const UNION1: _p::Descriptor<_p::Group> = (); + const UNION2: _p::Descriptor<_p::Group> = (); + const UNION3: _p::Descriptor<_p::Group> = (); + const BIT0: _p::Descriptor = _p::Descriptor:: { + slot: 128u32, + default: false, + }; + const BIT2: _p::Descriptor = _p::Descriptor:: { + slot: 130u32, + default: false, + }; + const BIT3: _p::Descriptor = _p::Descriptor:: { + slot: 131u32, + default: false, + }; + const BIT4: _p::Descriptor = _p::Descriptor:: { + slot: 132u32, + default: false, + }; + const BIT5: _p::Descriptor = _p::Descriptor:: { + slot: 133u32, + default: false, + }; + const BIT6: _p::Descriptor = _p::Descriptor:: { + slot: 134u32, + default: false, + }; + const BIT7: _p::Descriptor = _p::Descriptor:: { + slot: 135u32, + default: false, + }; + const BYTE0: _p::Descriptor = _p::Descriptor:: { + slot: 35u32, + default: 0u8, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_union::Reader<'p, T> { + #[inline] + pub fn union0(&self) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union0, + > as _p::field::FieldType>::accessor(&self.0, &TestUnion::UNION0) + } + } + #[inline] + pub fn union1(&self) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union1, + > as _p::field::FieldType>::accessor(&self.0, &TestUnion::UNION1) + } + } + #[inline] + pub fn union2(&self) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union2, + > as _p::field::FieldType>::accessor(&self.0, &TestUnion::UNION2) + } + } + #[inline] + pub fn union3(&self) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union3, + > as _p::field::FieldType>::accessor(&self.0, &TestUnion::UNION3) + } + } + #[inline] + pub fn bit0(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { ::accessor(&self.0, &TestUnion::BIT0) } + } + #[inline] + pub fn bit2(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { ::accessor(&self.0, &TestUnion::BIT2) } + } + #[inline] + pub fn bit3(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { ::accessor(&self.0, &TestUnion::BIT3) } + } + #[inline] + pub fn bit4(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { ::accessor(&self.0, &TestUnion::BIT4) } + } + #[inline] + pub fn bit5(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { ::accessor(&self.0, &TestUnion::BIT5) } + } + #[inline] + pub fn bit6(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { ::accessor(&self.0, &TestUnion::BIT6) } + } + #[inline] + pub fn bit7(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { ::accessor(&self.0, &TestUnion::BIT7) } + } + #[inline] + pub fn byte0(&self) -> _p::Accessor<'_, 'p, T, u8> { + unsafe { ::accessor(&self.0, &TestUnion::BYTE0) } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_union::Builder<'p, T> { + #[inline] + pub fn union0( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union0, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUnion::UNION0) + } + } + #[inline] + pub fn union1( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union1, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUnion::UNION1) + } + } + #[inline] + pub fn union2( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union2, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUnion::UNION2) + } + } + #[inline] + pub fn union3( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union3, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUnion::UNION3) + } + } + #[inline] + pub fn bit0(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor(&mut self.0, &TestUnion::BIT0) + } + } + #[inline] + pub fn bit2(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor(&mut self.0, &TestUnion::BIT2) + } + } + #[inline] + pub fn bit3(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor(&mut self.0, &TestUnion::BIT3) + } + } + #[inline] + pub fn bit4(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor(&mut self.0, &TestUnion::BIT4) + } + } + #[inline] + pub fn bit5(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor(&mut self.0, &TestUnion::BIT5) + } + } + #[inline] + pub fn bit6(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor(&mut self.0, &TestUnion::BIT6) + } + } + #[inline] + pub fn bit7(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor(&mut self.0, &TestUnion::BIT7) + } + } + #[inline] + pub fn byte0(&mut self) -> _p::AccessorMut<'_, 'p, T, u8> { + unsafe { ::accessor(&mut self.0, &TestUnion::BYTE0) } + } + #[inline] + pub fn into_union0(self) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union0, + > as _p::field::FieldType>::accessor(self.0, &TestUnion::UNION0) + } + } + #[inline] + pub fn into_union1(self) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union1, + > as _p::field::FieldType>::accessor(self.0, &TestUnion::UNION1) + } + } + #[inline] + pub fn into_union2(self) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union2, + > as _p::field::FieldType>::accessor(self.0, &TestUnion::UNION2) + } + } + #[inline] + pub fn into_union3(self) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union::Union3, + > as _p::field::FieldType>::accessor(self.0, &TestUnion::UNION3) + } + } +} +pub mod test_union { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestUnion<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestUnion< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct Union0(T); + impl _p::IntoFamily for Union0 { + type Family = Union0; + } + impl _p::Capable for Union0 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Union0>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Union0(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for union0::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for union0::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Union0(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: union0::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for union0::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for union0::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for union0::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: union0::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for union0::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for union0::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for union0::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Union0 { + type Reader<'a, T: _p::rpc::Table> = union0::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = union0::Builder<'a, T>; + } + impl _p::FieldGroup for Union0 { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(0usize, 0); + <() as _p::field::FieldType>::clear(s, &Union0::U0F0S0.field); + } + } + impl Union0 { + const U0F0S0: _p::VariantDescriptor<()> = _p::VariantDescriptor::<()> { + variant: _p::VariantInfo { + slot: 0u32, + case: 0u16, + }, + field: (), + }; + const U0F0S1: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 64u32, + default: false, + }, + }; + const U0F0S8: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 2u16, + }, + field: _p::Descriptor:: { + slot: 8u32, + default: 0i8, + }, + }; + const U0F0S16: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 3u16, + }, + field: _p::Descriptor:: { + slot: 4u32, + default: 0i16, + }, + }; + const U0F0S32: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 4u16, + }, + field: _p::Descriptor:: { + slot: 2u32, + default: 0i32, + }, + }; + const U0F0S64: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 5u16, + }, + field: _p::Descriptor:: { + slot: 1u32, + default: 0i64, + }, + }; + const U0F0SP: _p::VariantDescriptor<_p::Text> = _p::VariantDescriptor::< + _p::Text, + > { + variant: _p::VariantInfo { + slot: 0u32, + case: 6u16, + }, + field: _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }, + }; + const U0F1S0: _p::VariantDescriptor<()> = _p::VariantDescriptor::<()> { + variant: _p::VariantInfo { + slot: 0u32, + case: 7u16, + }, + field: (), + }; + const U0F1S1: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 8u16, + }, + field: _p::Descriptor:: { + slot: 64u32, + default: false, + }, + }; + const U0F1S8: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 9u16, + }, + field: _p::Descriptor:: { + slot: 8u32, + default: 0i8, + }, + }; + const U0F1S16: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 10u16, + }, + field: _p::Descriptor:: { + slot: 4u32, + default: 0i16, + }, + }; + const U0F1S32: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 11u16, + }, + field: _p::Descriptor:: { + slot: 2u32, + default: 0i32, + }, + }; + const U0F1S64: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 12u16, + }, + field: _p::Descriptor:: { + slot: 1u32, + default: 0i64, + }, + }; + const U0F1SP: _p::VariantDescriptor<_p::Text> = _p::VariantDescriptor::< + _p::Text, + > { + variant: _p::VariantInfo { + slot: 0u32, + case: 13u16, + }, + field: _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> union0::Reader<'p, T> { + #[inline] + pub fn u0f0s0(&self) -> _p::Variant<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::variant(&self.0, &Union0::U0F0S0) } + } + #[inline] + pub fn u0f0s1(&self) -> _p::Variant<'_, 'p, T, bool> { + unsafe { ::variant(&self.0, &Union0::U0F0S1) } + } + #[inline] + pub fn u0f0s8(&self) -> _p::Variant<'_, 'p, T, i8> { + unsafe { ::variant(&self.0, &Union0::U0F0S8) } + } + #[inline] + pub fn u0f0s16(&self) -> _p::Variant<'_, 'p, T, i16> { + unsafe { ::variant(&self.0, &Union0::U0F0S16) } + } + #[inline] + pub fn u0f0s32(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Union0::U0F0S32) } + } + #[inline] + pub fn u0f0s64(&self) -> _p::Variant<'_, 'p, T, i64> { + unsafe { ::variant(&self.0, &Union0::U0F0S64) } + } + #[inline] + pub fn u0f0sp(&self) -> _p::Variant<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&self.0, &Union0::U0F0SP) + } + } + #[inline] + pub fn u0f1s0(&self) -> _p::Variant<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::variant(&self.0, &Union0::U0F1S0) } + } + #[inline] + pub fn u0f1s1(&self) -> _p::Variant<'_, 'p, T, bool> { + unsafe { ::variant(&self.0, &Union0::U0F1S1) } + } + #[inline] + pub fn u0f1s8(&self) -> _p::Variant<'_, 'p, T, i8> { + unsafe { ::variant(&self.0, &Union0::U0F1S8) } + } + #[inline] + pub fn u0f1s16(&self) -> _p::Variant<'_, 'p, T, i16> { + unsafe { ::variant(&self.0, &Union0::U0F1S16) } + } + #[inline] + pub fn u0f1s32(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Union0::U0F1S32) } + } + #[inline] + pub fn u0f1s64(&self) -> _p::Variant<'_, 'p, T, i64> { + unsafe { ::variant(&self.0, &Union0::U0F1S64) } + } + #[inline] + pub fn u0f1sp(&self) -> _p::Variant<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&self.0, &Union0::U0F1SP) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> union0::Builder<'p, T> { + #[inline] + pub fn u0f0s0(&mut self) -> _p::VariantMut<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::variant(&mut self.0, &Union0::U0F0S0) + } + } + #[inline] + pub fn u0f0s1(&mut self) -> _p::VariantMut<'_, 'p, T, bool> { + unsafe { + ::variant(&mut self.0, &Union0::U0F0S1) + } + } + #[inline] + pub fn u0f0s8(&mut self) -> _p::VariantMut<'_, 'p, T, i8> { + unsafe { + ::variant(&mut self.0, &Union0::U0F0S8) + } + } + #[inline] + pub fn u0f0s16(&mut self) -> _p::VariantMut<'_, 'p, T, i16> { + unsafe { + ::variant(&mut self.0, &Union0::U0F0S16) + } + } + #[inline] + pub fn u0f0s32(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { + ::variant(&mut self.0, &Union0::U0F0S32) + } + } + #[inline] + pub fn u0f0s64(&mut self) -> _p::VariantMut<'_, 'p, T, i64> { + unsafe { + ::variant(&mut self.0, &Union0::U0F0S64) + } + } + #[inline] + pub fn u0f0sp(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&mut self.0, &Union0::U0F0SP) + } + } + #[inline] + pub fn u0f1s0(&mut self) -> _p::VariantMut<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::variant(&mut self.0, &Union0::U0F1S0) + } + } + #[inline] + pub fn u0f1s1(&mut self) -> _p::VariantMut<'_, 'p, T, bool> { + unsafe { + ::variant(&mut self.0, &Union0::U0F1S1) + } + } + #[inline] + pub fn u0f1s8(&mut self) -> _p::VariantMut<'_, 'p, T, i8> { + unsafe { + ::variant(&mut self.0, &Union0::U0F1S8) + } + } + #[inline] + pub fn u0f1s16(&mut self) -> _p::VariantMut<'_, 'p, T, i16> { + unsafe { + ::variant(&mut self.0, &Union0::U0F1S16) + } + } + #[inline] + pub fn u0f1s32(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { + ::variant(&mut self.0, &Union0::U0F1S32) + } + } + #[inline] + pub fn u0f1s64(&mut self) -> _p::VariantMut<'_, 'p, T, i64> { + unsafe { + ::variant(&mut self.0, &Union0::U0F1S64) + } + } + #[inline] + pub fn u0f1sp(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&mut self.0, &Union0::U0F1SP) + } + } + #[inline] + pub fn into_u0f0sp(self) -> _p::VariantOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(self.0, &Union0::U0F0SP) + } + } + #[inline] + pub fn into_u0f1sp(self) -> _p::VariantOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(self.0, &Union0::U0F1SP) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod union0 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Union0<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Union0< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + U0f0s0(_p::ViewOf), + U0f0s1(_p::ViewOf), + U0f0s8(_p::ViewOf), + U0f0s16(_p::ViewOf), + U0f0s32(_p::ViewOf), + U0f0s64(_p::ViewOf), + U0f0sp(_p::ViewOf), + U0f1s0(_p::ViewOf), + U0f1s1(_p::ViewOf), + U0f1s8(_p::ViewOf), + U0f1s16(_p::ViewOf), + U0f1s32(_p::ViewOf), + U0f1s64(_p::ViewOf), + U0f1sp(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::U0f0s0( + <() as _p::field::FieldType>::accessor( + &repr.0, + &super::Union0::U0F0S0.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::U0f0s1( + ::accessor( + &repr.0, + &super::Union0::U0F0S1.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::U0f0s8( + ::accessor( + &repr.0, + &super::Union0::U0F0S8.field, + ), + ), + ) + } + 3u16 => { + Ok( + Which::U0f0s16( + ::accessor( + &repr.0, + &super::Union0::U0F0S16.field, + ), + ), + ) + } + 4u16 => { + Ok( + Which::U0f0s32( + ::accessor( + &repr.0, + &super::Union0::U0F0S32.field, + ), + ), + ) + } + 5u16 => { + Ok( + Which::U0f0s64( + ::accessor( + &repr.0, + &super::Union0::U0F0S64.field, + ), + ), + ) + } + 6u16 => { + Ok( + Which::U0f0sp( + <_p::Text as _p::field::FieldType>::accessor( + &repr.0, + &super::Union0::U0F0SP.field, + ), + ), + ) + } + 7u16 => { + Ok( + Which::U0f1s0( + <() as _p::field::FieldType>::accessor( + &repr.0, + &super::Union0::U0F1S0.field, + ), + ), + ) + } + 8u16 => { + Ok( + Which::U0f1s1( + ::accessor( + &repr.0, + &super::Union0::U0F1S1.field, + ), + ), + ) + } + 9u16 => { + Ok( + Which::U0f1s8( + ::accessor( + &repr.0, + &super::Union0::U0F1S8.field, + ), + ), + ) + } + 10u16 => { + Ok( + Which::U0f1s16( + ::accessor( + &repr.0, + &super::Union0::U0F1S16.field, + ), + ), + ) + } + 11u16 => { + Ok( + Which::U0f1s32( + ::accessor( + &repr.0, + &super::Union0::U0F1S32.field, + ), + ), + ) + } + 12u16 => { + Ok( + Which::U0f1s64( + ::accessor( + &repr.0, + &super::Union0::U0F1S64.field, + ), + ), + ) + } + 13u16 => { + Ok( + Which::U0f1sp( + <_p::Text as _p::field::FieldType>::accessor( + &repr.0, + &super::Union0::U0F1SP.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::U0f0s0( + <() as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Union0::U0F0S0.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::U0f0s1( + ::accessor( + &mut repr.0, + &super::Union0::U0F0S1.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::U0f0s8( + ::accessor( + &mut repr.0, + &super::Union0::U0F0S8.field, + ), + ), + ) + } + 3u16 => { + Ok( + Which::U0f0s16( + ::accessor( + &mut repr.0, + &super::Union0::U0F0S16.field, + ), + ), + ) + } + 4u16 => { + Ok( + Which::U0f0s32( + ::accessor( + &mut repr.0, + &super::Union0::U0F0S32.field, + ), + ), + ) + } + 5u16 => { + Ok( + Which::U0f0s64( + ::accessor( + &mut repr.0, + &super::Union0::U0F0S64.field, + ), + ), + ) + } + 6u16 => { + Ok( + Which::U0f0sp( + <_p::Text as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Union0::U0F0SP.field, + ), + ), + ) + } + 7u16 => { + Ok( + Which::U0f1s0( + <() as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Union0::U0F1S0.field, + ), + ), + ) + } + 8u16 => { + Ok( + Which::U0f1s1( + ::accessor( + &mut repr.0, + &super::Union0::U0F1S1.field, + ), + ), + ) + } + 9u16 => { + Ok( + Which::U0f1s8( + ::accessor( + &mut repr.0, + &super::Union0::U0F1S8.field, + ), + ), + ) + } + 10u16 => { + Ok( + Which::U0f1s16( + ::accessor( + &mut repr.0, + &super::Union0::U0F1S16.field, + ), + ), + ) + } + 11u16 => { + Ok( + Which::U0f1s32( + ::accessor( + &mut repr.0, + &super::Union0::U0F1S32.field, + ), + ), + ) + } + 12u16 => { + Ok( + Which::U0f1s64( + ::accessor( + &mut repr.0, + &super::Union0::U0F1S64.field, + ), + ), + ) + } + 13u16 => { + Ok( + Which::U0f1sp( + <_p::Text as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Union0::U0F1SP.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + } + #[derive(Clone)] + pub struct Union1(T); + impl _p::IntoFamily for Union1 { + type Family = Union1; + } + impl _p::Capable for Union1 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Union1>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Union1(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for union1::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for union1::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Union1(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: union1::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for union1::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for union1::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for union1::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: union1::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for union1::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for union1::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for union1::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Union1 { + type Reader<'a, T: _p::rpc::Table> = union1::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = union1::Builder<'a, T>; + } + impl _p::FieldGroup for Union1 { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(1usize, 0); + <() as _p::field::FieldType>::clear(s, &Union1::U1F0S0.field); + } + } + impl Union1 { + const U1F0S0: _p::VariantDescriptor<()> = _p::VariantDescriptor::<()> { + variant: _p::VariantInfo { + slot: 1u32, + case: 0u16, + }, + field: (), + }; + const U1F0S1: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 129u32, + default: false, + }, + }; + const U1F1S1: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 2u16, + }, + field: _p::Descriptor:: { + slot: 129u32, + default: false, + }, + }; + const U1F0S8: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 3u16, + }, + field: _p::Descriptor:: { + slot: 17u32, + default: 0i8, + }, + }; + const U1F1S8: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 4u16, + }, + field: _p::Descriptor:: { + slot: 17u32, + default: 0i8, + }, + }; + const U1F0S16: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 5u16, + }, + field: _p::Descriptor:: { + slot: 9u32, + default: 0i16, + }, + }; + const U1F1S16: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 6u16, + }, + field: _p::Descriptor:: { + slot: 9u32, + default: 0i16, + }, + }; + const U1F0S32: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 7u16, + }, + field: _p::Descriptor:: { + slot: 5u32, + default: 0i32, + }, + }; + const U1F1S32: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 8u16, + }, + field: _p::Descriptor:: { + slot: 5u32, + default: 0i32, + }, + }; + const U1F0S64: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 9u16, + }, + field: _p::Descriptor:: { + slot: 3u32, + default: 0i64, + }, + }; + const U1F1S64: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 10u16, + }, + field: _p::Descriptor:: { + slot: 3u32, + default: 0i64, + }, + }; + const U1F0SP: _p::VariantDescriptor<_p::Text> = _p::VariantDescriptor::< + _p::Text, + > { + variant: _p::VariantInfo { + slot: 1u32, + case: 11u16, + }, + field: _p::Descriptor::<_p::Text> { + slot: 1u32, + default: ::core::option::Option::None, + }, + }; + const U1F1SP: _p::VariantDescriptor<_p::Text> = _p::VariantDescriptor::< + _p::Text, + > { + variant: _p::VariantInfo { + slot: 1u32, + case: 12u16, + }, + field: _p::Descriptor::<_p::Text> { + slot: 1u32, + default: ::core::option::Option::None, + }, + }; + const U1F2S0: _p::VariantDescriptor<()> = _p::VariantDescriptor::<()> { + variant: _p::VariantInfo { + slot: 1u32, + case: 13u16, + }, + field: (), + }; + const U1F2S1: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 14u16, + }, + field: _p::Descriptor:: { + slot: 129u32, + default: false, + }, + }; + const U1F2S8: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 15u16, + }, + field: _p::Descriptor:: { + slot: 17u32, + default: 0i8, + }, + }; + const U1F2S16: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 16u16, + }, + field: _p::Descriptor:: { + slot: 9u32, + default: 0i16, + }, + }; + const U1F2S32: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 17u16, + }, + field: _p::Descriptor:: { + slot: 5u32, + default: 0i32, + }, + }; + const U1F2S64: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 18u16, + }, + field: _p::Descriptor:: { + slot: 3u32, + default: 0i64, + }, + }; + const U1F2SP: _p::VariantDescriptor<_p::Text> = _p::VariantDescriptor::< + _p::Text, + > { + variant: _p::VariantInfo { + slot: 1u32, + case: 19u16, + }, + field: _p::Descriptor::<_p::Text> { + slot: 1u32, + default: ::core::option::Option::None, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> union1::Reader<'p, T> { + #[inline] + pub fn u1f0s0(&self) -> _p::Variant<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::variant(&self.0, &Union1::U1F0S0) } + } + #[inline] + pub fn u1f0s1(&self) -> _p::Variant<'_, 'p, T, bool> { + unsafe { ::variant(&self.0, &Union1::U1F0S1) } + } + #[inline] + pub fn u1f1s1(&self) -> _p::Variant<'_, 'p, T, bool> { + unsafe { ::variant(&self.0, &Union1::U1F1S1) } + } + #[inline] + pub fn u1f0s8(&self) -> _p::Variant<'_, 'p, T, i8> { + unsafe { ::variant(&self.0, &Union1::U1F0S8) } + } + #[inline] + pub fn u1f1s8(&self) -> _p::Variant<'_, 'p, T, i8> { + unsafe { ::variant(&self.0, &Union1::U1F1S8) } + } + #[inline] + pub fn u1f0s16(&self) -> _p::Variant<'_, 'p, T, i16> { + unsafe { ::variant(&self.0, &Union1::U1F0S16) } + } + #[inline] + pub fn u1f1s16(&self) -> _p::Variant<'_, 'p, T, i16> { + unsafe { ::variant(&self.0, &Union1::U1F1S16) } + } + #[inline] + pub fn u1f0s32(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Union1::U1F0S32) } + } + #[inline] + pub fn u1f1s32(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Union1::U1F1S32) } + } + #[inline] + pub fn u1f0s64(&self) -> _p::Variant<'_, 'p, T, i64> { + unsafe { ::variant(&self.0, &Union1::U1F0S64) } + } + #[inline] + pub fn u1f1s64(&self) -> _p::Variant<'_, 'p, T, i64> { + unsafe { ::variant(&self.0, &Union1::U1F1S64) } + } + #[inline] + pub fn u1f0sp(&self) -> _p::Variant<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&self.0, &Union1::U1F0SP) + } + } + #[inline] + pub fn u1f1sp(&self) -> _p::Variant<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&self.0, &Union1::U1F1SP) + } + } + #[inline] + pub fn u1f2s0(&self) -> _p::Variant<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::variant(&self.0, &Union1::U1F2S0) } + } + #[inline] + pub fn u1f2s1(&self) -> _p::Variant<'_, 'p, T, bool> { + unsafe { ::variant(&self.0, &Union1::U1F2S1) } + } + #[inline] + pub fn u1f2s8(&self) -> _p::Variant<'_, 'p, T, i8> { + unsafe { ::variant(&self.0, &Union1::U1F2S8) } + } + #[inline] + pub fn u1f2s16(&self) -> _p::Variant<'_, 'p, T, i16> { + unsafe { ::variant(&self.0, &Union1::U1F2S16) } + } + #[inline] + pub fn u1f2s32(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Union1::U1F2S32) } + } + #[inline] + pub fn u1f2s64(&self) -> _p::Variant<'_, 'p, T, i64> { + unsafe { ::variant(&self.0, &Union1::U1F2S64) } + } + #[inline] + pub fn u1f2sp(&self) -> _p::Variant<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&self.0, &Union1::U1F2SP) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> union1::Builder<'p, T> { + #[inline] + pub fn u1f0s0(&mut self) -> _p::VariantMut<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::variant(&mut self.0, &Union1::U1F0S0) + } + } + #[inline] + pub fn u1f0s1(&mut self) -> _p::VariantMut<'_, 'p, T, bool> { + unsafe { + ::variant(&mut self.0, &Union1::U1F0S1) + } + } + #[inline] + pub fn u1f1s1(&mut self) -> _p::VariantMut<'_, 'p, T, bool> { + unsafe { + ::variant(&mut self.0, &Union1::U1F1S1) + } + } + #[inline] + pub fn u1f0s8(&mut self) -> _p::VariantMut<'_, 'p, T, i8> { + unsafe { + ::variant(&mut self.0, &Union1::U1F0S8) + } + } + #[inline] + pub fn u1f1s8(&mut self) -> _p::VariantMut<'_, 'p, T, i8> { + unsafe { + ::variant(&mut self.0, &Union1::U1F1S8) + } + } + #[inline] + pub fn u1f0s16(&mut self) -> _p::VariantMut<'_, 'p, T, i16> { + unsafe { + ::variant(&mut self.0, &Union1::U1F0S16) + } + } + #[inline] + pub fn u1f1s16(&mut self) -> _p::VariantMut<'_, 'p, T, i16> { + unsafe { + ::variant(&mut self.0, &Union1::U1F1S16) + } + } + #[inline] + pub fn u1f0s32(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { + ::variant(&mut self.0, &Union1::U1F0S32) + } + } + #[inline] + pub fn u1f1s32(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { + ::variant(&mut self.0, &Union1::U1F1S32) + } + } + #[inline] + pub fn u1f0s64(&mut self) -> _p::VariantMut<'_, 'p, T, i64> { + unsafe { + ::variant(&mut self.0, &Union1::U1F0S64) + } + } + #[inline] + pub fn u1f1s64(&mut self) -> _p::VariantMut<'_, 'p, T, i64> { + unsafe { + ::variant(&mut self.0, &Union1::U1F1S64) + } + } + #[inline] + pub fn u1f0sp(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&mut self.0, &Union1::U1F0SP) + } + } + #[inline] + pub fn u1f1sp(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&mut self.0, &Union1::U1F1SP) + } + } + #[inline] + pub fn u1f2s0(&mut self) -> _p::VariantMut<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::variant(&mut self.0, &Union1::U1F2S0) + } + } + #[inline] + pub fn u1f2s1(&mut self) -> _p::VariantMut<'_, 'p, T, bool> { + unsafe { + ::variant(&mut self.0, &Union1::U1F2S1) + } + } + #[inline] + pub fn u1f2s8(&mut self) -> _p::VariantMut<'_, 'p, T, i8> { + unsafe { + ::variant(&mut self.0, &Union1::U1F2S8) + } + } + #[inline] + pub fn u1f2s16(&mut self) -> _p::VariantMut<'_, 'p, T, i16> { + unsafe { + ::variant(&mut self.0, &Union1::U1F2S16) + } + } + #[inline] + pub fn u1f2s32(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { + ::variant(&mut self.0, &Union1::U1F2S32) + } + } + #[inline] + pub fn u1f2s64(&mut self) -> _p::VariantMut<'_, 'p, T, i64> { + unsafe { + ::variant(&mut self.0, &Union1::U1F2S64) + } + } + #[inline] + pub fn u1f2sp(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&mut self.0, &Union1::U1F2SP) + } + } + #[inline] + pub fn into_u1f0sp(self) -> _p::VariantOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(self.0, &Union1::U1F0SP) + } + } + #[inline] + pub fn into_u1f1sp(self) -> _p::VariantOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(self.0, &Union1::U1F1SP) + } + } + #[inline] + pub fn into_u1f2sp(self) -> _p::VariantOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(self.0, &Union1::U1F2SP) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod union1 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Union1<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Union1< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + U1f0s0(_p::ViewOf), + U1f0s1(_p::ViewOf), + U1f1s1(_p::ViewOf), + U1f0s8(_p::ViewOf), + U1f1s8(_p::ViewOf), + U1f0s16(_p::ViewOf), + U1f1s16(_p::ViewOf), + U1f0s32(_p::ViewOf), + U1f1s32(_p::ViewOf), + U1f0s64(_p::ViewOf), + U1f1s64(_p::ViewOf), + U1f0sp(_p::ViewOf), + U1f1sp(_p::ViewOf), + U1f2s0(_p::ViewOf), + U1f2s1(_p::ViewOf), + U1f2s8(_p::ViewOf), + U1f2s16(_p::ViewOf), + U1f2s32(_p::ViewOf), + U1f2s64(_p::ViewOf), + U1f2sp(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(1usize); + match tag { + 0u16 => { + Ok( + Which::U1f0s0( + <() as _p::field::FieldType>::accessor( + &repr.0, + &super::Union1::U1F0S0.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::U1f0s1( + ::accessor( + &repr.0, + &super::Union1::U1F0S1.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::U1f1s1( + ::accessor( + &repr.0, + &super::Union1::U1F1S1.field, + ), + ), + ) + } + 3u16 => { + Ok( + Which::U1f0s8( + ::accessor( + &repr.0, + &super::Union1::U1F0S8.field, + ), + ), + ) + } + 4u16 => { + Ok( + Which::U1f1s8( + ::accessor( + &repr.0, + &super::Union1::U1F1S8.field, + ), + ), + ) + } + 5u16 => { + Ok( + Which::U1f0s16( + ::accessor( + &repr.0, + &super::Union1::U1F0S16.field, + ), + ), + ) + } + 6u16 => { + Ok( + Which::U1f1s16( + ::accessor( + &repr.0, + &super::Union1::U1F1S16.field, + ), + ), + ) + } + 7u16 => { + Ok( + Which::U1f0s32( + ::accessor( + &repr.0, + &super::Union1::U1F0S32.field, + ), + ), + ) + } + 8u16 => { + Ok( + Which::U1f1s32( + ::accessor( + &repr.0, + &super::Union1::U1F1S32.field, + ), + ), + ) + } + 9u16 => { + Ok( + Which::U1f0s64( + ::accessor( + &repr.0, + &super::Union1::U1F0S64.field, + ), + ), + ) + } + 10u16 => { + Ok( + Which::U1f1s64( + ::accessor( + &repr.0, + &super::Union1::U1F1S64.field, + ), + ), + ) + } + 11u16 => { + Ok( + Which::U1f0sp( + <_p::Text as _p::field::FieldType>::accessor( + &repr.0, + &super::Union1::U1F0SP.field, + ), + ), + ) + } + 12u16 => { + Ok( + Which::U1f1sp( + <_p::Text as _p::field::FieldType>::accessor( + &repr.0, + &super::Union1::U1F1SP.field, + ), + ), + ) + } + 13u16 => { + Ok( + Which::U1f2s0( + <() as _p::field::FieldType>::accessor( + &repr.0, + &super::Union1::U1F2S0.field, + ), + ), + ) + } + 14u16 => { + Ok( + Which::U1f2s1( + ::accessor( + &repr.0, + &super::Union1::U1F2S1.field, + ), + ), + ) + } + 15u16 => { + Ok( + Which::U1f2s8( + ::accessor( + &repr.0, + &super::Union1::U1F2S8.field, + ), + ), + ) + } + 16u16 => { + Ok( + Which::U1f2s16( + ::accessor( + &repr.0, + &super::Union1::U1F2S16.field, + ), + ), + ) + } + 17u16 => { + Ok( + Which::U1f2s32( + ::accessor( + &repr.0, + &super::Union1::U1F2S32.field, + ), + ), + ) + } + 18u16 => { + Ok( + Which::U1f2s64( + ::accessor( + &repr.0, + &super::Union1::U1F2S64.field, + ), + ), + ) + } + 19u16 => { + Ok( + Which::U1f2sp( + <_p::Text as _p::field::FieldType>::accessor( + &repr.0, + &super::Union1::U1F2SP.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(1usize); + match tag { + 0u16 => { + Ok( + Which::U1f0s0( + <() as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Union1::U1F0S0.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::U1f0s1( + ::accessor( + &mut repr.0, + &super::Union1::U1F0S1.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::U1f1s1( + ::accessor( + &mut repr.0, + &super::Union1::U1F1S1.field, + ), + ), + ) + } + 3u16 => { + Ok( + Which::U1f0s8( + ::accessor( + &mut repr.0, + &super::Union1::U1F0S8.field, + ), + ), + ) + } + 4u16 => { + Ok( + Which::U1f1s8( + ::accessor( + &mut repr.0, + &super::Union1::U1F1S8.field, + ), + ), + ) + } + 5u16 => { + Ok( + Which::U1f0s16( + ::accessor( + &mut repr.0, + &super::Union1::U1F0S16.field, + ), + ), + ) + } + 6u16 => { + Ok( + Which::U1f1s16( + ::accessor( + &mut repr.0, + &super::Union1::U1F1S16.field, + ), + ), + ) + } + 7u16 => { + Ok( + Which::U1f0s32( + ::accessor( + &mut repr.0, + &super::Union1::U1F0S32.field, + ), + ), + ) + } + 8u16 => { + Ok( + Which::U1f1s32( + ::accessor( + &mut repr.0, + &super::Union1::U1F1S32.field, + ), + ), + ) + } + 9u16 => { + Ok( + Which::U1f0s64( + ::accessor( + &mut repr.0, + &super::Union1::U1F0S64.field, + ), + ), + ) + } + 10u16 => { + Ok( + Which::U1f1s64( + ::accessor( + &mut repr.0, + &super::Union1::U1F1S64.field, + ), + ), + ) + } + 11u16 => { + Ok( + Which::U1f0sp( + <_p::Text as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Union1::U1F0SP.field, + ), + ), + ) + } + 12u16 => { + Ok( + Which::U1f1sp( + <_p::Text as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Union1::U1F1SP.field, + ), + ), + ) + } + 13u16 => { + Ok( + Which::U1f2s0( + <() as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Union1::U1F2S0.field, + ), + ), + ) + } + 14u16 => { + Ok( + Which::U1f2s1( + ::accessor( + &mut repr.0, + &super::Union1::U1F2S1.field, + ), + ), + ) + } + 15u16 => { + Ok( + Which::U1f2s8( + ::accessor( + &mut repr.0, + &super::Union1::U1F2S8.field, + ), + ), + ) + } + 16u16 => { + Ok( + Which::U1f2s16( + ::accessor( + &mut repr.0, + &super::Union1::U1F2S16.field, + ), + ), + ) + } + 17u16 => { + Ok( + Which::U1f2s32( + ::accessor( + &mut repr.0, + &super::Union1::U1F2S32.field, + ), + ), + ) + } + 18u16 => { + Ok( + Which::U1f2s64( + ::accessor( + &mut repr.0, + &super::Union1::U1F2S64.field, + ), + ), + ) + } + 19u16 => { + Ok( + Which::U1f2sp( + <_p::Text as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Union1::U1F2SP.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + } + #[derive(Clone)] + pub struct Union2(T); + impl _p::IntoFamily for Union2 { + type Family = Union2; + } + impl _p::Capable for Union2 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Union2>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Union2(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for union2::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for union2::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Union2(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: union2::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for union2::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for union2::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for union2::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: union2::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for union2::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for union2::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for union2::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Union2 { + type Reader<'a, T: _p::rpc::Table> = union2::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = union2::Builder<'a, T>; + } + impl _p::FieldGroup for Union2 { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(2usize, 0); + ::clear(s, &Union2::U2F0S1.field); + } + } + impl Union2 { + const U2F0S1: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 2u32, + case: 0u16, + }, + field: _p::Descriptor:: { + slot: 256u32, + default: false, + }, + }; + const U2F0S8: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 2u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 33u32, + default: 0i8, + }, + }; + const U2F0S16: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 2u32, + case: 2u16, + }, + field: _p::Descriptor:: { + slot: 18u32, + default: 0i16, + }, + }; + const U2F0S32: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 2u32, + case: 3u16, + }, + field: _p::Descriptor:: { + slot: 10u32, + default: 0i32, + }, + }; + const U2F0S64: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 2u32, + case: 4u16, + }, + field: _p::Descriptor:: { + slot: 6u32, + default: 0i64, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> union2::Reader<'p, T> { + #[inline] + pub fn u2f0s1(&self) -> _p::Variant<'_, 'p, T, bool> { + unsafe { ::variant(&self.0, &Union2::U2F0S1) } + } + #[inline] + pub fn u2f0s8(&self) -> _p::Variant<'_, 'p, T, i8> { + unsafe { ::variant(&self.0, &Union2::U2F0S8) } + } + #[inline] + pub fn u2f0s16(&self) -> _p::Variant<'_, 'p, T, i16> { + unsafe { ::variant(&self.0, &Union2::U2F0S16) } + } + #[inline] + pub fn u2f0s32(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Union2::U2F0S32) } + } + #[inline] + pub fn u2f0s64(&self) -> _p::Variant<'_, 'p, T, i64> { + unsafe { ::variant(&self.0, &Union2::U2F0S64) } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> union2::Builder<'p, T> { + #[inline] + pub fn u2f0s1(&mut self) -> _p::VariantMut<'_, 'p, T, bool> { + unsafe { + ::variant(&mut self.0, &Union2::U2F0S1) + } + } + #[inline] + pub fn u2f0s8(&mut self) -> _p::VariantMut<'_, 'p, T, i8> { + unsafe { + ::variant(&mut self.0, &Union2::U2F0S8) + } + } + #[inline] + pub fn u2f0s16(&mut self) -> _p::VariantMut<'_, 'p, T, i16> { + unsafe { + ::variant(&mut self.0, &Union2::U2F0S16) + } + } + #[inline] + pub fn u2f0s32(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { + ::variant(&mut self.0, &Union2::U2F0S32) + } + } + #[inline] + pub fn u2f0s64(&mut self) -> _p::VariantMut<'_, 'p, T, i64> { + unsafe { + ::variant(&mut self.0, &Union2::U2F0S64) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod union2 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Union2<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Union2< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + U2f0s1(_p::ViewOf), + U2f0s8(_p::ViewOf), + U2f0s16(_p::ViewOf), + U2f0s32(_p::ViewOf), + U2f0s64(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(2usize); + match tag { + 0u16 => { + Ok( + Which::U2f0s1( + ::accessor( + &repr.0, + &super::Union2::U2F0S1.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::U2f0s8( + ::accessor( + &repr.0, + &super::Union2::U2F0S8.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::U2f0s16( + ::accessor( + &repr.0, + &super::Union2::U2F0S16.field, + ), + ), + ) + } + 3u16 => { + Ok( + Which::U2f0s32( + ::accessor( + &repr.0, + &super::Union2::U2F0S32.field, + ), + ), + ) + } + 4u16 => { + Ok( + Which::U2f0s64( + ::accessor( + &repr.0, + &super::Union2::U2F0S64.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(2usize); + match tag { + 0u16 => { + Ok( + Which::U2f0s1( + ::accessor( + &mut repr.0, + &super::Union2::U2F0S1.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::U2f0s8( + ::accessor( + &mut repr.0, + &super::Union2::U2F0S8.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::U2f0s16( + ::accessor( + &mut repr.0, + &super::Union2::U2F0S16.field, + ), + ), + ) + } + 3u16 => { + Ok( + Which::U2f0s32( + ::accessor( + &mut repr.0, + &super::Union2::U2F0S32.field, + ), + ), + ) + } + 4u16 => { + Ok( + Which::U2f0s64( + ::accessor( + &mut repr.0, + &super::Union2::U2F0S64.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + } + #[derive(Clone)] + pub struct Union3(T); + impl _p::IntoFamily for Union3 { + type Family = Union3; + } + impl _p::Capable for Union3 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Union3>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Union3(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for union3::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for union3::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Union3(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: union3::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for union3::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for union3::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for union3::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: union3::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for union3::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for union3::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for union3::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Union3 { + type Reader<'a, T: _p::rpc::Table> = union3::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = union3::Builder<'a, T>; + } + impl _p::FieldGroup for Union3 { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(3usize, 0); + ::clear(s, &Union3::U3F0S1.field); + } + } + impl Union3 { + const U3F0S1: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 3u32, + case: 0u16, + }, + field: _p::Descriptor:: { + slot: 257u32, + default: false, + }, + }; + const U3F0S8: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 3u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 34u32, + default: 0i8, + }, + }; + const U3F0S16: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 3u32, + case: 2u16, + }, + field: _p::Descriptor:: { + slot: 19u32, + default: 0i16, + }, + }; + const U3F0S32: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 3u32, + case: 3u16, + }, + field: _p::Descriptor:: { + slot: 11u32, + default: 0i32, + }, + }; + const U3F0S64: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 3u32, + case: 4u16, + }, + field: _p::Descriptor:: { + slot: 7u32, + default: 0i64, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> union3::Reader<'p, T> { + #[inline] + pub fn u3f0s1(&self) -> _p::Variant<'_, 'p, T, bool> { + unsafe { ::variant(&self.0, &Union3::U3F0S1) } + } + #[inline] + pub fn u3f0s8(&self) -> _p::Variant<'_, 'p, T, i8> { + unsafe { ::variant(&self.0, &Union3::U3F0S8) } + } + #[inline] + pub fn u3f0s16(&self) -> _p::Variant<'_, 'p, T, i16> { + unsafe { ::variant(&self.0, &Union3::U3F0S16) } + } + #[inline] + pub fn u3f0s32(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Union3::U3F0S32) } + } + #[inline] + pub fn u3f0s64(&self) -> _p::Variant<'_, 'p, T, i64> { + unsafe { ::variant(&self.0, &Union3::U3F0S64) } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> union3::Builder<'p, T> { + #[inline] + pub fn u3f0s1(&mut self) -> _p::VariantMut<'_, 'p, T, bool> { + unsafe { + ::variant(&mut self.0, &Union3::U3F0S1) + } + } + #[inline] + pub fn u3f0s8(&mut self) -> _p::VariantMut<'_, 'p, T, i8> { + unsafe { + ::variant(&mut self.0, &Union3::U3F0S8) + } + } + #[inline] + pub fn u3f0s16(&mut self) -> _p::VariantMut<'_, 'p, T, i16> { + unsafe { + ::variant(&mut self.0, &Union3::U3F0S16) + } + } + #[inline] + pub fn u3f0s32(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { + ::variant(&mut self.0, &Union3::U3F0S32) + } + } + #[inline] + pub fn u3f0s64(&mut self) -> _p::VariantMut<'_, 'p, T, i64> { + unsafe { + ::variant(&mut self.0, &Union3::U3F0S64) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod union3 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Union3<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Union3< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + U3f0s1(_p::ViewOf), + U3f0s8(_p::ViewOf), + U3f0s16(_p::ViewOf), + U3f0s32(_p::ViewOf), + U3f0s64(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(3usize); + match tag { + 0u16 => { + Ok( + Which::U3f0s1( + ::accessor( + &repr.0, + &super::Union3::U3F0S1.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::U3f0s8( + ::accessor( + &repr.0, + &super::Union3::U3F0S8.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::U3f0s16( + ::accessor( + &repr.0, + &super::Union3::U3F0S16.field, + ), + ), + ) + } + 3u16 => { + Ok( + Which::U3f0s32( + ::accessor( + &repr.0, + &super::Union3::U3F0S32.field, + ), + ), + ) + } + 4u16 => { + Ok( + Which::U3f0s64( + ::accessor( + &repr.0, + &super::Union3::U3F0S64.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(3usize); + match tag { + 0u16 => { + Ok( + Which::U3f0s1( + ::accessor( + &mut repr.0, + &super::Union3::U3F0S1.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::U3f0s8( + ::accessor( + &mut repr.0, + &super::Union3::U3F0S8.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::U3f0s16( + ::accessor( + &mut repr.0, + &super::Union3::U3F0S16.field, + ), + ), + ) + } + 3u16 => { + Ok( + Which::U3f0s32( + ::accessor( + &mut repr.0, + &super::Union3::U3F0S32.field, + ), + ), + ) + } + 4u16 => { + Ok( + Which::U3f0s64( + ::accessor( + &mut repr.0, + &super::Union3::U3F0S64.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + } +} +#[derive(Clone)] +pub struct TestUnnamedUnion(T); +impl _p::IntoFamily for TestUnnamedUnion { + type Family = TestUnnamedUnion; +} +impl _p::Capable for TestUnnamedUnion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestUnnamedUnion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestUnnamedUnion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_unnamed_union::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_unnamed_union::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestUnnamedUnion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_unnamed_union::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_unnamed_union::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_unnamed_union::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_unnamed_union::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_unnamed_union::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_unnamed_union::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_unnamed_union::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_unnamed_union::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestUnnamedUnion { + type Reader<'a, T: _p::rpc::Table> = test_unnamed_union::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_unnamed_union::Builder<'a, T>; +} +impl _p::ty::Struct for TestUnnamedUnion { + const SIZE: _p::StructSize = _p::StructSize { + data: 2u16, + ptrs: 2u16, + }; +} +impl TestUnnamedUnion { + const BEFORE: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const MIDDLE: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: 0u16, + }; + const AFTER: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 1u32, + default: ::core::option::Option::None, + }; + const FOO: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 2u32, + case: 0u16, + }, + field: _p::Descriptor:: { + slot: 0u32, + default: 0u16, + }, + }; + const BAR: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 2u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 2u32, + default: 0u32, + }, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_unnamed_union::Reader<'p, T> { + #[inline] + pub fn before(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &TestUnnamedUnion::BEFORE, + ) + } + } + #[inline] + pub fn middle(&self) -> _p::Accessor<'_, 'p, T, u16> { + unsafe { + ::accessor(&self.0, &TestUnnamedUnion::MIDDLE) + } + } + #[inline] + pub fn after(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &TestUnnamedUnion::AFTER, + ) + } + } + #[inline] + pub fn foo(&self) -> _p::Variant<'_, 'p, T, u16> { + unsafe { + ::variant(&self.0, &TestUnnamedUnion::FOO) + } + } + #[inline] + pub fn bar(&self) -> _p::Variant<'_, 'p, T, u32> { + unsafe { + ::variant(&self.0, &TestUnnamedUnion::BAR) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_unnamed_union::Builder<'p, T> { + #[inline] + pub fn before(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestUnnamedUnion::BEFORE, + ) + } + } + #[inline] + pub fn middle(&mut self) -> _p::AccessorMut<'_, 'p, T, u16> { + unsafe { + ::accessor( + &mut self.0, + &TestUnnamedUnion::MIDDLE, + ) + } + } + #[inline] + pub fn after(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestUnnamedUnion::AFTER, + ) + } + } + #[inline] + pub fn foo(&mut self) -> _p::VariantMut<'_, 'p, T, u16> { + unsafe { + ::variant(&mut self.0, &TestUnnamedUnion::FOO) + } + } + #[inline] + pub fn bar(&mut self) -> _p::VariantMut<'_, 'p, T, u32> { + unsafe { + ::variant(&mut self.0, &TestUnnamedUnion::BAR) + } + } + #[inline] + pub fn into_before(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + self.0, + &TestUnnamedUnion::BEFORE, + ) + } + } + #[inline] + pub fn into_after(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + self.0, + &TestUnnamedUnion::AFTER, + ) + } + } + #[inline] + pub fn which( + &mut self, + ) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +pub mod test_unnamed_union { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestUnnamedUnion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestUnnamedUnion< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Foo(_p::ViewOf), + Bar(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get(repr: &'b Reader<'p, T>) -> Result { + let tag = repr.0.data_field::(2usize); + match tag { + 0u16 => { + Ok( + Which::Foo( + ::accessor( + &repr.0, + &super::TestUnnamedUnion::FOO.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Bar( + ::accessor( + &repr.0, + &super::TestUnnamedUnion::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(2usize); + match tag { + 0u16 => { + Ok( + Which::Foo( + ::accessor( + &mut repr.0, + &super::TestUnnamedUnion::FOO.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Bar( + ::accessor( + &mut repr.0, + &super::TestUnnamedUnion::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } +} +#[derive(Clone)] +pub struct TestUnionInUnion(T); +impl _p::IntoFamily for TestUnionInUnion { + type Family = TestUnionInUnion; +} +impl _p::Capable for TestUnionInUnion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestUnionInUnion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestUnionInUnion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_union_in_union::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_union_in_union::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestUnionInUnion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_union_in_union::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_union_in_union::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_union_in_union::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_union_in_union::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_union_in_union::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_union_in_union::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_union_in_union::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_union_in_union::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestUnionInUnion { + type Reader<'a, T: _p::rpc::Table> = test_union_in_union::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_union_in_union::Builder<'a, T>; +} +impl _p::ty::Struct for TestUnionInUnion { + const SIZE: _p::StructSize = _p::StructSize { + data: 2u16, + ptrs: 0u16, + }; +} +impl TestUnionInUnion { + const OUTER: _p::Descriptor<_p::Group> = (); +} +impl<'p, T: _p::rpc::Table + 'p> test_union_in_union::Reader<'p, T> { + #[inline] + pub fn outer( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union_in_union::Outer, + > as _p::field::FieldType>::accessor(&self.0, &TestUnionInUnion::OUTER) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_union_in_union::Builder<'p, T> { + #[inline] + pub fn outer( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union_in_union::Outer, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUnionInUnion::OUTER) + } + } + #[inline] + pub fn into_outer( + self, + ) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_union_in_union::Outer, + > as _p::field::FieldType>::accessor(self.0, &TestUnionInUnion::OUTER) + } + } +} +pub mod test_union_in_union { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestUnionInUnion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestUnionInUnion< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct Outer(T); + impl _p::IntoFamily for Outer { + type Family = Outer; + } + impl _p::Capable for Outer { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Outer>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Outer(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for outer::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for outer::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Outer(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: outer::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for outer::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for outer::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for outer::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: outer::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for outer::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for outer::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for outer::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Outer { + type Reader<'a, T: _p::rpc::Table> = outer::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = outer::Builder<'a, T>; + } + impl _p::FieldGroup for Outer { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(4usize, 0); + <_p::Group< + outer::Inner, + > as _p::field::FieldType>::clear(s, &Outer::INNER.field); + } + } + impl Outer { + const INNER: _p::VariantDescriptor<_p::Group> = _p::VariantDescriptor::< + _p::Group, + > { + variant: _p::VariantInfo { + slot: 4u32, + case: 0u16, + }, + field: (), + }; + const BAZ: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 4u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 0u32, + default: 0i32, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> outer::Reader<'p, T> { + #[inline] + pub fn inner(&self) -> _p::Variant<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + outer::Inner, + > as _p::field::FieldType>::variant(&self.0, &Outer::INNER) + } + } + #[inline] + pub fn baz(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Outer::BAZ) } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> outer::Builder<'p, T> { + #[inline] + pub fn inner(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + outer::Inner, + > as _p::field::FieldType>::variant(&mut self.0, &Outer::INNER) + } + } + #[inline] + pub fn baz(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { ::variant(&mut self.0, &Outer::BAZ) } + } + #[inline] + pub fn into_inner(self) -> _p::VariantOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + outer::Inner, + > as _p::field::FieldType>::variant(self.0, &Outer::INNER) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod outer { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Outer<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Outer< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Inner(_p::ViewOf>), + Baz(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(4usize); + match tag { + 0u16 => { + Ok( + Which::Inner( + <_p::Group< + Inner, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::Outer::INNER.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Baz( + ::accessor( + &repr.0, + &super::Outer::BAZ.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(4usize); + match tag { + 0u16 => { + Ok( + Which::Inner( + <_p::Group< + Inner, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Outer::INNER.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Baz( + ::accessor( + &mut repr.0, + &super::Outer::BAZ.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + #[derive(Clone)] + pub struct Inner(T); + impl _p::IntoFamily for Inner { + type Family = Inner; + } + impl _p::Capable for Inner { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Inner>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Inner(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for inner::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for inner::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Inner(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: inner::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for inner::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for inner::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for inner::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: inner::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for inner::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for inner::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for inner::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Inner { + type Reader<'a, T: _p::rpc::Table> = inner::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = inner::Builder<'a, T>; + } + impl _p::FieldGroup for Inner { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>( + s: &'a mut _p::StructBuilder<'b, T>, + ) { + s.set_field_unchecked(2usize, 0); + ::clear(s, &Inner::FOO.field); + } + } + impl Inner { + const FOO: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 2u32, + case: 0u16, + }, + field: _p::Descriptor:: { + slot: 0u32, + default: 0i32, + }, + }; + const BAR: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 2u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 0u32, + default: 0i32, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> inner::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Inner::FOO) } + } + #[inline] + pub fn bar(&self) -> _p::Variant<'_, 'p, T, i32> { + unsafe { ::variant(&self.0, &Inner::BAR) } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> inner::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { + ::variant(&mut self.0, &Inner::FOO) + } + } + #[inline] + pub fn bar(&mut self) -> _p::VariantMut<'_, 'p, T, i32> { + unsafe { + ::variant(&mut self.0, &Inner::BAR) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod inner { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Inner< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Inner< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Foo(_p::ViewOf), + Bar(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(2usize); + match tag { + 0u16 => { + Ok( + Which::Foo( + ::accessor( + &repr.0, + &super::Inner::FOO.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Bar( + ::accessor( + &repr.0, + &super::Inner::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(2usize); + match tag { + 0u16 => { + Ok( + Which::Foo( + ::accessor( + &mut repr.0, + &super::Inner::FOO.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Bar( + ::accessor( + &mut repr.0, + &super::Inner::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + } + } +} +#[derive(Clone)] +pub struct TestGroups(T); +impl _p::IntoFamily for TestGroups { + type Family = TestGroups; +} +impl _p::Capable for TestGroups { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestGroups>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestGroups(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_groups::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_groups::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestGroups(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_groups::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_groups::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_groups::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_groups::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_groups::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_groups::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_groups::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_groups::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestGroups { + type Reader<'a, T: _p::rpc::Table> = test_groups::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_groups::Builder<'a, T>; +} +impl _p::ty::Struct for TestGroups { + const SIZE: _p::StructSize = _p::StructSize { + data: 2u16, + ptrs: 2u16, + }; +} +impl TestGroups { + const GROUPS: _p::Descriptor<_p::Group> = (); +} +impl<'p, T: _p::rpc::Table + 'p> test_groups::Reader<'p, T> { + #[inline] + pub fn groups(&self) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_groups::Groups, + > as _p::field::FieldType>::accessor(&self.0, &TestGroups::GROUPS) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_groups::Builder<'p, T> { + #[inline] + pub fn groups( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_groups::Groups, + > as _p::field::FieldType>::accessor(&mut self.0, &TestGroups::GROUPS) + } + } + #[inline] + pub fn into_groups( + self, + ) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_groups::Groups, + > as _p::field::FieldType>::accessor(self.0, &TestGroups::GROUPS) + } + } +} +pub mod test_groups { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestGroups<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestGroups< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct Groups(T); + impl _p::IntoFamily for Groups { + type Family = Groups; + } + impl _p::Capable for Groups { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Groups>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Groups(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for groups::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for groups::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Groups(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: groups::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for groups::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for groups::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for groups::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: groups::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for groups::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for groups::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for groups::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Groups { + type Reader<'a, T: _p::rpc::Table> = groups::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = groups::Builder<'a, T>; + } + impl _p::FieldGroup for Groups { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(2usize, 0); + <_p::Group< + groups::Foo, + > as _p::field::FieldType>::clear(s, &Groups::FOO.field); + } + } + impl Groups { + const FOO: _p::VariantDescriptor<_p::Group> = _p::VariantDescriptor::< + _p::Group, + > { + variant: _p::VariantInfo { + slot: 2u32, + case: 0u16, + }, + field: (), + }; + const BAZ: _p::VariantDescriptor<_p::Group> = _p::VariantDescriptor::< + _p::Group, + > { + variant: _p::VariantInfo { + slot: 2u32, + case: 1u16, + }, + field: (), + }; + const BAR: _p::VariantDescriptor<_p::Group> = _p::VariantDescriptor::< + _p::Group, + > { + variant: _p::VariantInfo { + slot: 2u32, + case: 2u16, + }, + field: (), + }; + } + impl<'p, T: _p::rpc::Table + 'p> groups::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Variant<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + groups::Foo, + > as _p::field::FieldType>::variant(&self.0, &Groups::FOO) + } + } + #[inline] + pub fn baz(&self) -> _p::Variant<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + groups::Baz, + > as _p::field::FieldType>::variant(&self.0, &Groups::BAZ) + } + } + #[inline] + pub fn bar(&self) -> _p::Variant<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + groups::Bar, + > as _p::field::FieldType>::variant(&self.0, &Groups::BAR) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> groups::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + groups::Foo, + > as _p::field::FieldType>::variant(&mut self.0, &Groups::FOO) + } + } + #[inline] + pub fn baz(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + groups::Baz, + > as _p::field::FieldType>::variant(&mut self.0, &Groups::BAZ) + } + } + #[inline] + pub fn bar(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + groups::Bar, + > as _p::field::FieldType>::variant(&mut self.0, &Groups::BAR) + } + } + #[inline] + pub fn into_foo(self) -> _p::VariantOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + groups::Foo, + > as _p::field::FieldType>::variant(self.0, &Groups::FOO) + } + } + #[inline] + pub fn into_baz(self) -> _p::VariantOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + groups::Baz, + > as _p::field::FieldType>::variant(self.0, &Groups::BAZ) + } + } + #[inline] + pub fn into_bar(self) -> _p::VariantOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + groups::Bar, + > as _p::field::FieldType>::variant(self.0, &Groups::BAR) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod groups { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Groups<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Groups< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Foo(_p::ViewOf>), + Baz(_p::ViewOf>), + Bar(_p::ViewOf>), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(2usize); + match tag { + 0u16 => { + Ok( + Which::Foo( + <_p::Group< + Foo, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::Groups::FOO.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Baz( + <_p::Group< + Baz, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::Groups::BAZ.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Bar( + <_p::Group< + Bar, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::Groups::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(2usize); + match tag { + 0u16 => { + Ok( + Which::Foo( + <_p::Group< + Foo, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Groups::FOO.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Baz( + <_p::Group< + Baz, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Groups::BAZ.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Bar( + <_p::Group< + Bar, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Groups::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + #[derive(Clone)] + pub struct Foo(T); + impl _p::IntoFamily for Foo { + type Family = Foo; + } + impl _p::Capable for Foo { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Foo>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Foo(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for foo::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for foo::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Foo(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: foo::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for foo::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for foo::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for foo::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: foo::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for foo::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for foo::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for foo::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Foo { + type Reader<'a, T: _p::rpc::Table> = foo::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = foo::Builder<'a, T>; + } + impl _p::FieldGroup for Foo { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>( + s: &'a mut _p::StructBuilder<'b, T>, + ) { + ::clear(s, &Foo::CORGE); + ::clear(s, &Foo::GRAULT); + <_p::Text as _p::field::FieldType>::clear(s, &Foo::GARPLY); + } + } + impl Foo { + const CORGE: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0i32, + }; + const GRAULT: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: 0i64, + }; + const GARPLY: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> foo::Reader<'p, T> { + #[inline] + pub fn corge(&self) -> _p::Accessor<'_, 'p, T, i32> { + unsafe { ::accessor(&self.0, &Foo::CORGE) } + } + #[inline] + pub fn grault(&self) -> _p::Accessor<'_, 'p, T, i64> { + unsafe { ::accessor(&self.0, &Foo::GRAULT) } + } + #[inline] + pub fn garply(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Foo::GARPLY) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> foo::Builder<'p, T> { + #[inline] + pub fn corge(&mut self) -> _p::AccessorMut<'_, 'p, T, i32> { + unsafe { + ::accessor(&mut self.0, &Foo::CORGE) + } + } + #[inline] + pub fn grault(&mut self) -> _p::AccessorMut<'_, 'p, T, i64> { + unsafe { + ::accessor(&mut self.0, &Foo::GRAULT) + } + } + #[inline] + pub fn garply(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Foo::GARPLY, + ) + } + } + #[inline] + pub fn into_garply(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Foo::GARPLY) + } + } + } + pub mod foo { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Foo< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Foo< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Baz(T); + impl _p::IntoFamily for Baz { + type Family = Baz; + } + impl _p::Capable for Baz { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Baz>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Baz(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for baz::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for baz::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Baz(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: baz::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for baz::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for baz::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for baz::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: baz::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for baz::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for baz::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for baz::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Baz { + type Reader<'a, T: _p::rpc::Table> = baz::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = baz::Builder<'a, T>; + } + impl _p::FieldGroup for Baz { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>( + s: &'a mut _p::StructBuilder<'b, T>, + ) { + ::clear(s, &Baz::CORGE); + <_p::Text as _p::field::FieldType>::clear(s, &Baz::GRAULT); + <_p::Text as _p::field::FieldType>::clear(s, &Baz::GARPLY); + } + } + impl Baz { + const CORGE: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0i32, + }; + const GRAULT: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const GARPLY: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 1u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> baz::Reader<'p, T> { + #[inline] + pub fn corge(&self) -> _p::Accessor<'_, 'p, T, i32> { + unsafe { ::accessor(&self.0, &Baz::CORGE) } + } + #[inline] + pub fn grault(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Baz::GRAULT) + } + } + #[inline] + pub fn garply(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Baz::GARPLY) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> baz::Builder<'p, T> { + #[inline] + pub fn corge(&mut self) -> _p::AccessorMut<'_, 'p, T, i32> { + unsafe { + ::accessor(&mut self.0, &Baz::CORGE) + } + } + #[inline] + pub fn grault(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Baz::GRAULT, + ) + } + } + #[inline] + pub fn garply(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Baz::GARPLY, + ) + } + } + #[inline] + pub fn into_grault(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Baz::GRAULT) + } + } + #[inline] + pub fn into_garply(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Baz::GARPLY) + } + } + } + pub mod baz { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Baz< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Baz< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Bar(T); + impl _p::IntoFamily for Bar { + type Family = Bar; + } + impl _p::Capable for Bar { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Bar>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Bar(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for bar::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for bar::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Bar(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: bar::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for bar::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for bar::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for bar::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: bar::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for bar::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for bar::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for bar::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Bar { + type Reader<'a, T: _p::rpc::Table> = bar::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = bar::Builder<'a, T>; + } + impl _p::FieldGroup for Bar { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>( + s: &'a mut _p::StructBuilder<'b, T>, + ) { + ::clear(s, &Bar::CORGE); + <_p::Text as _p::field::FieldType>::clear(s, &Bar::GRAULT); + ::clear(s, &Bar::GARPLY); + } + } + impl Bar { + const CORGE: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0i32, + }; + const GRAULT: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const GARPLY: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: 0i64, + }; + } + impl<'p, T: _p::rpc::Table + 'p> bar::Reader<'p, T> { + #[inline] + pub fn corge(&self) -> _p::Accessor<'_, 'p, T, i32> { + unsafe { ::accessor(&self.0, &Bar::CORGE) } + } + #[inline] + pub fn grault(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Bar::GRAULT) + } + } + #[inline] + pub fn garply(&self) -> _p::Accessor<'_, 'p, T, i64> { + unsafe { ::accessor(&self.0, &Bar::GARPLY) } + } + } + impl<'p, T: _p::rpc::Table + 'p> bar::Builder<'p, T> { + #[inline] + pub fn corge(&mut self) -> _p::AccessorMut<'_, 'p, T, i32> { + unsafe { + ::accessor(&mut self.0, &Bar::CORGE) + } + } + #[inline] + pub fn grault(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Bar::GRAULT, + ) + } + } + #[inline] + pub fn garply(&mut self) -> _p::AccessorMut<'_, 'p, T, i64> { + unsafe { + ::accessor(&mut self.0, &Bar::GARPLY) + } + } + #[inline] + pub fn into_grault(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Bar::GRAULT) + } + } + } + pub mod bar { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Bar< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Bar< + _p::StructBuilder<'a, T>, + >; + } + } +} +#[derive(Clone)] +pub struct TestInterleavedGroups(T); +impl _p::IntoFamily for TestInterleavedGroups { + type Family = TestInterleavedGroups; +} +impl _p::Capable for TestInterleavedGroups { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestInterleavedGroups>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestInterleavedGroups(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_interleaved_groups::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_interleaved_groups::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestInterleavedGroups(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_interleaved_groups::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_interleaved_groups::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_interleaved_groups::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_interleaved_groups::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_interleaved_groups::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_interleaved_groups::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_interleaved_groups::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_interleaved_groups::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestInterleavedGroups { + type Reader<'a, T: _p::rpc::Table> = test_interleaved_groups::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_interleaved_groups::Builder<'a, T>; +} +impl _p::ty::Struct for TestInterleavedGroups { + const SIZE: _p::StructSize = _p::StructSize { + data: 6u16, + ptrs: 6u16, + }; +} +impl TestInterleavedGroups { + const GROUP1: _p::Descriptor<_p::Group> = (); + const GROUP2: _p::Descriptor<_p::Group> = (); +} +impl<'p, T: _p::rpc::Table + 'p> test_interleaved_groups::Reader<'p, T> { + #[inline] + pub fn group1( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_interleaved_groups::Group1, + > as _p::field::FieldType>::accessor(&self.0, &TestInterleavedGroups::GROUP1) + } + } + #[inline] + pub fn group2( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_interleaved_groups::Group2, + > as _p::field::FieldType>::accessor(&self.0, &TestInterleavedGroups::GROUP2) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_interleaved_groups::Builder<'p, T> { + #[inline] + pub fn group1( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_interleaved_groups::Group1, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestInterleavedGroups::GROUP1, + ) + } + } + #[inline] + pub fn group2( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_interleaved_groups::Group2, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestInterleavedGroups::GROUP2, + ) + } + } + #[inline] + pub fn into_group1( + self, + ) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_interleaved_groups::Group1, + > as _p::field::FieldType>::accessor(self.0, &TestInterleavedGroups::GROUP1) + } + } + #[inline] + pub fn into_group2( + self, + ) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_interleaved_groups::Group2, + > as _p::field::FieldType>::accessor(self.0, &TestInterleavedGroups::GROUP2) + } + } +} +pub mod test_interleaved_groups { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestInterleavedGroups< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestInterleavedGroups< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct Group1(T); + impl _p::IntoFamily for Group1 { + type Family = Group1; + } + impl _p::Capable for Group1 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Group1>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Group1(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for group1::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for group1::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Group1(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: group1::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for group1::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for group1::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for group1::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: group1::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for group1::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for group1::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for group1::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Group1 { + type Reader<'a, T: _p::rpc::Table> = group1::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = group1::Builder<'a, T>; + } + impl _p::FieldGroup for Group1 { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + ::clear(s, &Group1::FOO); + ::clear(s, &Group1::BAR); + <_p::Text as _p::field::FieldType>::clear(s, &Group1::WALDO); + s.set_field_unchecked(14usize, 0); + ::clear(s, &Group1::QUX.field); + } + } + impl Group1 { + const FOO: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u32, + }; + const BAR: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: 0u64, + }; + const WALDO: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const QUX: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 14u32, + case: 0u16, + }, + field: _p::Descriptor:: { + slot: 12u32, + default: 0u16, + }, + }; + const CORGE: _p::VariantDescriptor<_p::Group> = _p::VariantDescriptor::< + _p::Group, + > { + variant: _p::VariantInfo { + slot: 14u32, + case: 1u16, + }, + field: (), + }; + const FRED: _p::VariantDescriptor<_p::Text> = _p::VariantDescriptor::<_p::Text> { + variant: _p::VariantInfo { + slot: 14u32, + case: 2u16, + }, + field: _p::Descriptor::<_p::Text> { + slot: 2u32, + default: ::core::option::Option::None, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> group1::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, u32> { + unsafe { ::accessor(&self.0, &Group1::FOO) } + } + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, u64> { + unsafe { ::accessor(&self.0, &Group1::BAR) } + } + #[inline] + pub fn waldo(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Group1::WALDO) + } + } + #[inline] + pub fn qux(&self) -> _p::Variant<'_, 'p, T, u16> { + unsafe { ::variant(&self.0, &Group1::QUX) } + } + #[inline] + pub fn corge(&self) -> _p::Variant<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + group1::Corge, + > as _p::field::FieldType>::variant(&self.0, &Group1::CORGE) + } + } + #[inline] + pub fn fred(&self) -> _p::Variant<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&self.0, &Group1::FRED) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> group1::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, u32> { + unsafe { ::accessor(&mut self.0, &Group1::FOO) } + } + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, u64> { + unsafe { ::accessor(&mut self.0, &Group1::BAR) } + } + #[inline] + pub fn waldo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &Group1::WALDO) + } + } + #[inline] + pub fn qux(&mut self) -> _p::VariantMut<'_, 'p, T, u16> { + unsafe { ::variant(&mut self.0, &Group1::QUX) } + } + #[inline] + pub fn corge(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + group1::Corge, + > as _p::field::FieldType>::variant(&mut self.0, &Group1::CORGE) + } + } + #[inline] + pub fn fred(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&mut self.0, &Group1::FRED) + } + } + #[inline] + pub fn into_waldo(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Group1::WALDO) + } + } + #[inline] + pub fn into_corge(self) -> _p::VariantOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + group1::Corge, + > as _p::field::FieldType>::variant(self.0, &Group1::CORGE) + } + } + #[inline] + pub fn into_fred(self) -> _p::VariantOwned<'p, T, _p::Text> { + unsafe { <_p::Text as _p::field::FieldType>::variant(self.0, &Group1::FRED) } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod group1 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Group1<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Group1< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Qux(_p::ViewOf), + Corge(_p::ViewOf>), + Fred(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(14usize); + match tag { + 0u16 => { + Ok( + Which::Qux( + ::accessor( + &repr.0, + &super::Group1::QUX.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Corge( + <_p::Group< + Corge, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::Group1::CORGE.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Fred( + <_p::Text as _p::field::FieldType>::accessor( + &repr.0, + &super::Group1::FRED.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(14usize); + match tag { + 0u16 => { + Ok( + Which::Qux( + ::accessor( + &mut repr.0, + &super::Group1::QUX.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Corge( + <_p::Group< + Corge, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Group1::CORGE.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Fred( + <_p::Text as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Group1::FRED.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + #[derive(Clone)] + pub struct Corge(T); + impl _p::IntoFamily for Corge { + type Family = Corge; + } + impl _p::Capable for Corge { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Corge>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Corge(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for corge::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for corge::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Corge(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: corge::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for corge::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for corge::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for corge::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: corge::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for corge::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for corge::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for corge::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Corge { + type Reader<'a, T: _p::rpc::Table> = corge::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = corge::Builder<'a, T>; + } + impl _p::FieldGroup for Corge { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>( + s: &'a mut _p::StructBuilder<'b, T>, + ) { + ::clear(s, &Corge::GRAULT); + ::clear(s, &Corge::GARPLY); + <_p::Text as _p::field::FieldType>::clear(s, &Corge::PLUGH); + <_p::Text as _p::field::FieldType>::clear(s, &Corge::XYZZY); + } + } + impl Corge { + const GRAULT: _p::Descriptor = _p::Descriptor:: { + slot: 4u32, + default: 0u64, + }; + const GARPLY: _p::Descriptor = _p::Descriptor:: { + slot: 12u32, + default: 0u16, + }; + const PLUGH: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 2u32, + default: ::core::option::Option::None, + }; + const XYZZY: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 4u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> corge::Reader<'p, T> { + #[inline] + pub fn grault(&self) -> _p::Accessor<'_, 'p, T, u64> { + unsafe { + ::accessor(&self.0, &Corge::GRAULT) + } + } + #[inline] + pub fn garply(&self) -> _p::Accessor<'_, 'p, T, u16> { + unsafe { + ::accessor(&self.0, &Corge::GARPLY) + } + } + #[inline] + pub fn plugh(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Corge::PLUGH) + } + } + #[inline] + pub fn xyzzy(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Corge::XYZZY) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> corge::Builder<'p, T> { + #[inline] + pub fn grault(&mut self) -> _p::AccessorMut<'_, 'p, T, u64> { + unsafe { + ::accessor(&mut self.0, &Corge::GRAULT) + } + } + #[inline] + pub fn garply(&mut self) -> _p::AccessorMut<'_, 'p, T, u16> { + unsafe { + ::accessor(&mut self.0, &Corge::GARPLY) + } + } + #[inline] + pub fn plugh(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Corge::PLUGH, + ) + } + } + #[inline] + pub fn xyzzy(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Corge::XYZZY, + ) + } + } + #[inline] + pub fn into_plugh(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Corge::PLUGH) + } + } + #[inline] + pub fn into_xyzzy(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Corge::XYZZY) + } + } + } + pub mod corge { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Corge< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Corge< + _p::StructBuilder<'a, T>, + >; + } + } + #[derive(Clone)] + pub struct Group2(T); + impl _p::IntoFamily for Group2 { + type Family = Group2; + } + impl _p::Capable for Group2 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Group2>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Group2(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for group2::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for group2::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Group2(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: group2::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for group2::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for group2::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for group2::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: group2::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for group2::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for group2::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for group2::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Group2 { + type Reader<'a, T: _p::rpc::Table> = group2::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = group2::Builder<'a, T>; + } + impl _p::FieldGroup for Group2 { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + ::clear(s, &Group2::FOO); + ::clear(s, &Group2::BAR); + <_p::Text as _p::field::FieldType>::clear(s, &Group2::WALDO); + s.set_field_unchecked(15usize, 0); + ::clear(s, &Group2::QUX.field); + } + } + impl Group2 { + const FOO: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: 0u32, + }; + const BAR: _p::Descriptor = _p::Descriptor:: { + slot: 2u32, + default: 0u64, + }; + const WALDO: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 1u32, + default: ::core::option::Option::None, + }; + const QUX: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 15u32, + case: 0u16, + }, + field: _p::Descriptor:: { + slot: 13u32, + default: 0u16, + }, + }; + const CORGE: _p::VariantDescriptor<_p::Group> = _p::VariantDescriptor::< + _p::Group, + > { + variant: _p::VariantInfo { + slot: 15u32, + case: 1u16, + }, + field: (), + }; + const FRED: _p::VariantDescriptor<_p::Text> = _p::VariantDescriptor::<_p::Text> { + variant: _p::VariantInfo { + slot: 15u32, + case: 2u16, + }, + field: _p::Descriptor::<_p::Text> { + slot: 3u32, + default: ::core::option::Option::None, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> group2::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, u32> { + unsafe { ::accessor(&self.0, &Group2::FOO) } + } + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, u64> { + unsafe { ::accessor(&self.0, &Group2::BAR) } + } + #[inline] + pub fn waldo(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Group2::WALDO) + } + } + #[inline] + pub fn qux(&self) -> _p::Variant<'_, 'p, T, u16> { + unsafe { ::variant(&self.0, &Group2::QUX) } + } + #[inline] + pub fn corge(&self) -> _p::Variant<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + group2::Corge, + > as _p::field::FieldType>::variant(&self.0, &Group2::CORGE) + } + } + #[inline] + pub fn fred(&self) -> _p::Variant<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&self.0, &Group2::FRED) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> group2::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, u32> { + unsafe { ::accessor(&mut self.0, &Group2::FOO) } + } + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, u64> { + unsafe { ::accessor(&mut self.0, &Group2::BAR) } + } + #[inline] + pub fn waldo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &Group2::WALDO) + } + } + #[inline] + pub fn qux(&mut self) -> _p::VariantMut<'_, 'p, T, u16> { + unsafe { ::variant(&mut self.0, &Group2::QUX) } + } + #[inline] + pub fn corge(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + group2::Corge, + > as _p::field::FieldType>::variant(&mut self.0, &Group2::CORGE) + } + } + #[inline] + pub fn fred(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&mut self.0, &Group2::FRED) + } + } + #[inline] + pub fn into_waldo(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Group2::WALDO) + } + } + #[inline] + pub fn into_corge(self) -> _p::VariantOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + group2::Corge, + > as _p::field::FieldType>::variant(self.0, &Group2::CORGE) + } + } + #[inline] + pub fn into_fred(self) -> _p::VariantOwned<'p, T, _p::Text> { + unsafe { <_p::Text as _p::field::FieldType>::variant(self.0, &Group2::FRED) } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod group2 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Group2<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Group2< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Qux(_p::ViewOf), + Corge(_p::ViewOf>), + Fred(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(15usize); + match tag { + 0u16 => { + Ok( + Which::Qux( + ::accessor( + &repr.0, + &super::Group2::QUX.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Corge( + <_p::Group< + Corge, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::Group2::CORGE.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Fred( + <_p::Text as _p::field::FieldType>::accessor( + &repr.0, + &super::Group2::FRED.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(15usize); + match tag { + 0u16 => { + Ok( + Which::Qux( + ::accessor( + &mut repr.0, + &super::Group2::QUX.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Corge( + <_p::Group< + Corge, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Group2::CORGE.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Fred( + <_p::Text as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Group2::FRED.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + #[derive(Clone)] + pub struct Corge(T); + impl _p::IntoFamily for Corge { + type Family = Corge; + } + impl _p::Capable for Corge { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Corge>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Corge(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for corge::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for corge::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Corge(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: corge::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for corge::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for corge::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for corge::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: corge::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for corge::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for corge::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for corge::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Corge { + type Reader<'a, T: _p::rpc::Table> = corge::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = corge::Builder<'a, T>; + } + impl _p::FieldGroup for Corge { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>( + s: &'a mut _p::StructBuilder<'b, T>, + ) { + ::clear(s, &Corge::GRAULT); + ::clear(s, &Corge::GARPLY); + <_p::Text as _p::field::FieldType>::clear(s, &Corge::PLUGH); + <_p::Text as _p::field::FieldType>::clear(s, &Corge::XYZZY); + } + } + impl Corge { + const GRAULT: _p::Descriptor = _p::Descriptor:: { + slot: 5u32, + default: 0u64, + }; + const GARPLY: _p::Descriptor = _p::Descriptor:: { + slot: 13u32, + default: 0u16, + }; + const PLUGH: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 3u32, + default: ::core::option::Option::None, + }; + const XYZZY: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 5u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> corge::Reader<'p, T> { + #[inline] + pub fn grault(&self) -> _p::Accessor<'_, 'p, T, u64> { + unsafe { + ::accessor(&self.0, &Corge::GRAULT) + } + } + #[inline] + pub fn garply(&self) -> _p::Accessor<'_, 'p, T, u16> { + unsafe { + ::accessor(&self.0, &Corge::GARPLY) + } + } + #[inline] + pub fn plugh(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Corge::PLUGH) + } + } + #[inline] + pub fn xyzzy(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Corge::XYZZY) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> corge::Builder<'p, T> { + #[inline] + pub fn grault(&mut self) -> _p::AccessorMut<'_, 'p, T, u64> { + unsafe { + ::accessor(&mut self.0, &Corge::GRAULT) + } + } + #[inline] + pub fn garply(&mut self) -> _p::AccessorMut<'_, 'p, T, u16> { + unsafe { + ::accessor(&mut self.0, &Corge::GARPLY) + } + } + #[inline] + pub fn plugh(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Corge::PLUGH, + ) + } + } + #[inline] + pub fn xyzzy(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Corge::XYZZY, + ) + } + } + #[inline] + pub fn into_plugh(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Corge::PLUGH) + } + } + #[inline] + pub fn into_xyzzy(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Corge::XYZZY) + } + } + } + pub mod corge { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Corge< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Corge< + _p::StructBuilder<'a, T>, + >; + } + } +} +#[derive(Clone)] +pub struct TestUnionDefaults(T); +impl _p::IntoFamily for TestUnionDefaults { + type Family = TestUnionDefaults; +} +impl _p::Capable for TestUnionDefaults { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestUnionDefaults>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestUnionDefaults(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_union_defaults::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_union_defaults::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestUnionDefaults(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_union_defaults::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_union_defaults::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_union_defaults::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_union_defaults::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_union_defaults::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_union_defaults::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_union_defaults::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_union_defaults::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestUnionDefaults { + type Reader<'a, T: _p::rpc::Table> = test_union_defaults::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_union_defaults::Builder<'a, T>; +} +impl _p::ty::Struct for TestUnionDefaults { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 4u16, + }; +} +impl TestUnionDefaults { + const S16S8S64S8_SET: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([3u8, 0u8, 3u8, 0u8, 4u8, 0u8, 1u8, 0u8]), + _p::Word([65u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 55u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([135u8, 75u8, 107u8, 93u8, 84u8, 220u8, 43u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 8u16, + ptrs: 2u16, + }, + ) + }), + }; + const S0SPS1S32_SET: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 1u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([7u8, 0u8, 11u8, 0u8, 0u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 78u8, 97u8, 188u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 8u16, + ptrs: 2u16, + }, + ) + }), + }; + const UNNAMED1: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 2u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([123u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 2u16, + ptrs: 2u16, + }, + ) + }), + }; + const UNNAMED2: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 3u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 1u8, 0u8, 0u8, 0u8]), + _p::Word([65u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 114u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 2u16, + ptrs: 2u16, + }, + ) + }), + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_union_defaults::Reader<'p, T> { + #[inline] + pub fn s16s8s64s8_set(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnion, + > as _p::field::FieldType>::accessor( + &self.0, + &TestUnionDefaults::S16S8S64S8_SET, + ) + } + } + #[inline] + pub fn s0sps1s32_set(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnion, + > as _p::field::FieldType>::accessor( + &self.0, + &TestUnionDefaults::S0SPS1S32_SET, + ) + } + } + #[inline] + pub fn unnamed1(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnnamedUnion, + > as _p::field::FieldType>::accessor(&self.0, &TestUnionDefaults::UNNAMED1) + } + } + #[inline] + pub fn unnamed2(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnnamedUnion, + > as _p::field::FieldType>::accessor(&self.0, &TestUnionDefaults::UNNAMED2) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_union_defaults::Builder<'p, T> { + #[inline] + pub fn s16s8s64s8_set( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnion, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUnionDefaults::S16S8S64S8_SET, + ) + } + } + #[inline] + pub fn s0sps1s32_set( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnion, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUnionDefaults::S0SPS1S32_SET, + ) + } + } + #[inline] + pub fn unnamed1( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnnamedUnion, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUnionDefaults::UNNAMED1, + ) + } + } + #[inline] + pub fn unnamed2( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnnamedUnion, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUnionDefaults::UNNAMED2, + ) + } + } + #[inline] + pub fn into_s16s8s64s8_set(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnion, + > as _p::field::FieldType>::accessor( + self.0, + &TestUnionDefaults::S16S8S64S8_SET, + ) + } + } + #[inline] + pub fn into_s0sps1s32_set(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnion, + > as _p::field::FieldType>::accessor( + self.0, + &TestUnionDefaults::S0SPS1S32_SET, + ) + } + } + #[inline] + pub fn into_unnamed1( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnnamedUnion, + > as _p::field::FieldType>::accessor(self.0, &TestUnionDefaults::UNNAMED1) + } + } + #[inline] + pub fn into_unnamed2( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUnnamedUnion, + > as _p::field::FieldType>::accessor(self.0, &TestUnionDefaults::UNNAMED2) + } + } +} +pub mod test_union_defaults { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestUnionDefaults< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestUnionDefaults< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestNestedTypes(T); +impl _p::IntoFamily for TestNestedTypes { + type Family = TestNestedTypes; +} +impl _p::Capable for TestNestedTypes { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestNestedTypes>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestNestedTypes(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_nested_types::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_nested_types::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestNestedTypes(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_nested_types::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_nested_types::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_nested_types::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_nested_types::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_nested_types::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_nested_types::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_nested_types::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_nested_types::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestNestedTypes { + type Reader<'a, T: _p::rpc::Table> = test_nested_types::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_nested_types::Builder<'a, T>; +} +impl _p::ty::Struct for TestNestedTypes { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; +} +impl TestNestedTypes { + const NESTED_STRUCT: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; + const OUTER_NESTED_ENUM: _p::Descriptor<_p::Enum> = _p::Descriptor::< + _p::Enum, + > { + slot: 0u32, + default: test_nested_types::NestedEnum::Bar, + }; + const INNER_NESTED_ENUM: _p::Descriptor< + _p::Enum, + > = _p::Descriptor::<_p::Enum> { + slot: 1u32, + default: test_nested_types::nested_struct::NestedEnum::Quux, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_nested_types::Reader<'p, T> { + #[inline] + pub fn nested_struct( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_nested_types::NestedStruct, + > as _p::field::FieldType>::accessor( + &self.0, + &TestNestedTypes::NESTED_STRUCT, + ) + } + } + #[inline] + pub fn outer_nested_enum( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + test_nested_types::NestedEnum, + > as _p::field::FieldType>::accessor( + &self.0, + &TestNestedTypes::OUTER_NESTED_ENUM, + ) + } + } + #[inline] + pub fn inner_nested_enum( + &self, + ) -> _p::Accessor< + '_, + 'p, + T, + _p::Enum, + > { + unsafe { + <_p::Enum< + test_nested_types::nested_struct::NestedEnum, + > as _p::field::FieldType>::accessor( + &self.0, + &TestNestedTypes::INNER_NESTED_ENUM, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_nested_types::Builder<'p, T> { + #[inline] + pub fn nested_struct( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_nested_types::NestedStruct, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestNestedTypes::NESTED_STRUCT, + ) + } + } + #[inline] + pub fn outer_nested_enum( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + test_nested_types::NestedEnum, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestNestedTypes::OUTER_NESTED_ENUM, + ) + } + } + #[inline] + pub fn inner_nested_enum( + &mut self, + ) -> _p::AccessorMut< + '_, + 'p, + T, + _p::Enum, + > { + unsafe { + <_p::Enum< + test_nested_types::nested_struct::NestedEnum, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestNestedTypes::INNER_NESTED_ENUM, + ) + } + } + #[inline] + pub fn into_nested_struct( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_nested_types::NestedStruct, + > as _p::field::FieldType>::accessor(self.0, &TestNestedTypes::NESTED_STRUCT) + } + } +} +pub mod test_nested_types { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestNestedTypes< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestNestedTypes< + _p::StructBuilder<'a, T>, + >; + #[repr(u16)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)] + pub enum NestedEnum { + #[default] + Foo, + Bar, + } + impl core::convert::TryFrom for NestedEnum { + type Error = _p::NotInSchema; + #[inline] + fn try_from(value: u16) -> Result { + match value { + 0u16 => Ok(Self::Foo), + 1u16 => Ok(Self::Bar), + value => Err(_p::NotInSchema(value)), + } + } + } + impl core::convert::From for u16 { + #[inline] + fn from(value: NestedEnum) -> Self { + value as u16 + } + } + impl _p::ty::Enum for NestedEnum {} + #[derive(Clone)] + pub struct NestedStruct(T); + impl _p::IntoFamily for NestedStruct { + type Family = NestedStruct; + } + impl _p::Capable for NestedStruct { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = NestedStruct>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (NestedStruct(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for nested_struct::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for nested_struct::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + NestedStruct(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: nested_struct::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for nested_struct::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for nested_struct::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for nested_struct::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: nested_struct::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for nested_struct::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for nested_struct::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for nested_struct::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for NestedStruct { + type Reader<'a, T: _p::rpc::Table> = nested_struct::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = nested_struct::Builder<'a, T>; + } + impl _p::ty::Struct for NestedStruct { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; + } + impl NestedStruct { + const OUTER_NESTED_ENUM: _p::Descriptor<_p::Enum> = _p::Descriptor::< + _p::Enum, + > { + slot: 0u32, + default: NestedEnum::Bar, + }; + const INNER_NESTED_ENUM: _p::Descriptor<_p::Enum> = _p::Descriptor::< + _p::Enum, + > { + slot: 1u32, + default: nested_struct::NestedEnum::Quux, + }; + } + impl<'p, T: _p::rpc::Table + 'p> nested_struct::Reader<'p, T> { + #[inline] + pub fn outer_nested_enum( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + NestedEnum, + > as _p::field::FieldType>::accessor( + &self.0, + &NestedStruct::OUTER_NESTED_ENUM, + ) + } + } + #[inline] + pub fn inner_nested_enum( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + nested_struct::NestedEnum, + > as _p::field::FieldType>::accessor( + &self.0, + &NestedStruct::INNER_NESTED_ENUM, + ) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> nested_struct::Builder<'p, T> { + #[inline] + pub fn outer_nested_enum( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + NestedEnum, + > as _p::field::FieldType>::accessor( + &mut self.0, + &NestedStruct::OUTER_NESTED_ENUM, + ) + } + } + #[inline] + pub fn inner_nested_enum( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + nested_struct::NestedEnum, + > as _p::field::FieldType>::accessor( + &mut self.0, + &NestedStruct::INNER_NESTED_ENUM, + ) + } + } + } + pub mod nested_struct { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::NestedStruct< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::NestedStruct< + _p::StructBuilder<'a, T>, + >; + #[repr(u16)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)] + pub enum NestedEnum { + #[default] + Baz, + Qux, + Quux, + } + impl core::convert::TryFrom for NestedEnum { + type Error = _p::NotInSchema; + #[inline] + fn try_from(value: u16) -> Result { + match value { + 0u16 => Ok(Self::Baz), + 1u16 => Ok(Self::Qux), + 2u16 => Ok(Self::Quux), + value => Err(_p::NotInSchema(value)), + } + } + } + impl core::convert::From for u16 { + #[inline] + fn from(value: NestedEnum) -> Self { + value as u16 + } + } + impl _p::ty::Enum for NestedEnum {} + } +} +#[derive(Clone)] +pub struct TestUsing(T); +impl _p::IntoFamily for TestUsing { + type Family = TestUsing; +} +impl _p::Capable for TestUsing { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestUsing>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestUsing(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_using::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_using::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestUsing(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_using::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_using::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_using::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_using::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_using::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_using::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_using::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_using::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestUsing { + type Reader<'a, T: _p::rpc::Table> = test_using::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_using::Builder<'a, T>; +} +impl _p::ty::Struct for TestUsing { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; +} +impl TestUsing { + const INNER_NESTED_ENUM: _p::Descriptor< + _p::Enum, + > = _p::Descriptor::<_p::Enum> { + slot: 0u32, + default: test_nested_types::nested_struct::NestedEnum::Quux, + }; + const OUTER_NESTED_ENUM: _p::Descriptor<_p::Enum> = _p::Descriptor::< + _p::Enum, + > { + slot: 1u32, + default: test_nested_types::NestedEnum::Bar, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_using::Reader<'p, T> { + #[inline] + pub fn inner_nested_enum( + &self, + ) -> _p::Accessor< + '_, + 'p, + T, + _p::Enum, + > { + unsafe { + <_p::Enum< + test_nested_types::nested_struct::NestedEnum, + > as _p::field::FieldType>::accessor(&self.0, &TestUsing::INNER_NESTED_ENUM) + } + } + #[inline] + pub fn outer_nested_enum( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + test_nested_types::NestedEnum, + > as _p::field::FieldType>::accessor(&self.0, &TestUsing::OUTER_NESTED_ENUM) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_using::Builder<'p, T> { + #[inline] + pub fn inner_nested_enum( + &mut self, + ) -> _p::AccessorMut< + '_, + 'p, + T, + _p::Enum, + > { + unsafe { + <_p::Enum< + test_nested_types::nested_struct::NestedEnum, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUsing::INNER_NESTED_ENUM, + ) + } + } + #[inline] + pub fn outer_nested_enum( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + test_nested_types::NestedEnum, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUsing::OUTER_NESTED_ENUM, + ) + } + } +} +pub mod test_using { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestUsing<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestUsing< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestLists(T); +impl _p::IntoFamily for TestLists { + type Family = TestLists; +} +impl _p::Capable for TestLists { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestLists>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestLists(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_lists::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_lists::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestLists(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_lists::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_lists::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_lists::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_lists::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_lists::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_lists::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_lists::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_lists::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestLists { + type Reader<'a, T: _p::rpc::Table> = test_lists::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_lists::Builder<'a, T>; +} +impl _p::ty::Struct for TestLists { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 10u16, + }; +} +impl TestLists { + const LIST0: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; + const LIST1: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; + const LIST8: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 2u32, + default: ::core::option::Option::None, + }; + const LIST16: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 3u32, + default: ::core::option::Option::None, + }; + const LIST32: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 4u32, + default: ::core::option::Option::None, + }; + const LIST64: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 5u32, + default: ::core::option::Option::None, + }; + const LIST_P: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 6u32, + default: ::core::option::Option::None, + }; + const INT32_LIST_LIST: _p::Descriptor<_p::List<_p::List>> = _p::Descriptor::< + _p::List<_p::List>, + > { + slot: 7u32, + default: ::core::option::Option::None, + }; + const TEXT_LIST_LIST: _p::Descriptor<_p::List<_p::List<_p::Text>>> = _p::Descriptor::< + _p::List<_p::List<_p::Text>>, + > { + slot: 8u32, + default: ::core::option::Option::None, + }; + const STRUCT_LIST_LIST: _p::Descriptor< + _p::List<_p::List<_p::Struct>>, + > = _p::Descriptor::<_p::List<_p::List<_p::Struct>>> { + slot: 9u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_lists::Reader<'p, T> { + #[inline] + pub fn list0( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::LIST0) + } + } + #[inline] + pub fn list1( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::LIST1) + } + } + #[inline] + pub fn list8( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::LIST8) + } + } + #[inline] + pub fn list16( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::LIST16) + } + } + #[inline] + pub fn list32( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::LIST32) + } + } + #[inline] + pub fn list64( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::LIST64) + } + } + #[inline] + pub fn list_p( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::LIST_P) + } + } + #[inline] + pub fn int32_list_list(&self) -> _p::Accessor<'_, 'p, T, _p::List<_p::List>> { + unsafe { + <_p::List< + _p::List, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::INT32_LIST_LIST) + } + } + #[inline] + pub fn text_list_list( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::List<_p::Text>>> { + unsafe { + <_p::List< + _p::List<_p::Text>, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::TEXT_LIST_LIST) + } + } + #[inline] + pub fn struct_list_list( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::List<_p::Struct>>> { + unsafe { + <_p::List< + _p::List<_p::Struct>, + > as _p::field::FieldType>::accessor(&self.0, &TestLists::STRUCT_LIST_LIST) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_lists::Builder<'p, T> { + #[inline] + pub fn list0( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestLists::LIST0) + } + } + #[inline] + pub fn list1( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestLists::LIST1) + } + } + #[inline] + pub fn list8( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestLists::LIST8) + } + } + #[inline] + pub fn list16( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestLists::LIST16) + } + } + #[inline] + pub fn list32( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestLists::LIST32) + } + } + #[inline] + pub fn list64( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestLists::LIST64) + } + } + #[inline] + pub fn list_p( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestLists::LIST_P) + } + } + #[inline] + pub fn int32_list_list( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::List>> { + unsafe { + <_p::List< + _p::List, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestLists::INT32_LIST_LIST, + ) + } + } + #[inline] + pub fn text_list_list( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::List<_p::Text>>> { + unsafe { + <_p::List< + _p::List<_p::Text>, + > as _p::field::FieldType>::accessor(&mut self.0, &TestLists::TEXT_LIST_LIST) + } + } + #[inline] + pub fn struct_list_list( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::List<_p::Struct>>> { + unsafe { + <_p::List< + _p::List<_p::Struct>, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestLists::STRUCT_LIST_LIST, + ) + } + } + #[inline] + pub fn into_list0( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestLists::LIST0) + } + } + #[inline] + pub fn into_list1( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestLists::LIST1) + } + } + #[inline] + pub fn into_list8( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestLists::LIST8) + } + } + #[inline] + pub fn into_list16( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestLists::LIST16) + } + } + #[inline] + pub fn into_list32( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestLists::LIST32) + } + } + #[inline] + pub fn into_list64( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestLists::LIST64) + } + } + #[inline] + pub fn into_list_p( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestLists::LIST_P) + } + } + #[inline] + pub fn into_int32_list_list( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::List>> { + unsafe { + <_p::List< + _p::List, + > as _p::field::FieldType>::accessor(self.0, &TestLists::INT32_LIST_LIST) + } + } + #[inline] + pub fn into_text_list_list( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::List<_p::Text>>> { + unsafe { + <_p::List< + _p::List<_p::Text>, + > as _p::field::FieldType>::accessor(self.0, &TestLists::TEXT_LIST_LIST) + } + } + #[inline] + pub fn into_struct_list_list( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::List<_p::Struct>>> { + unsafe { + <_p::List< + _p::List<_p::Struct>, + > as _p::field::FieldType>::accessor(self.0, &TestLists::STRUCT_LIST_LIST) + } + } +} +pub mod test_lists { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestLists<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestLists< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct Struct0(T); + impl _p::IntoFamily for Struct0 { + type Family = Struct0; + } + impl _p::Capable for Struct0 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct0>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct0(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct0::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct0::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct0(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct0::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct0::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct0::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct0::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct0::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct0::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct0::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct0::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct0 { + type Reader<'a, T: _p::rpc::Table> = struct0::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct0::Builder<'a, T>; + } + impl _p::ty::Struct for Struct0 { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 0u16, + }; + } + impl Struct0 { + const F: _p::Descriptor<()> = (); + } + impl<'p, T: _p::rpc::Table + 'p> struct0::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::accessor(&self.0, &Struct0::F) } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct0::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::accessor(&mut self.0, &Struct0::F) } + } + } + pub mod struct0 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct0< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct0< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct1(T); + impl _p::IntoFamily for Struct1 { + type Family = Struct1; + } + impl _p::Capable for Struct1 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct1>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct1(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct1::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct1::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct1(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct1::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct1::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct1::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct1::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct1::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct1::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct1::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct1::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct1 { + type Reader<'a, T: _p::rpc::Table> = struct1::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct1::Builder<'a, T>; + } + impl _p::ty::Struct for Struct1 { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; + } + impl Struct1 { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: false, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct1::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { ::accessor(&self.0, &Struct1::F) } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct1::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { ::accessor(&mut self.0, &Struct1::F) } + } + } + pub mod struct1 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct1< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct1< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct8(T); + impl _p::IntoFamily for Struct8 { + type Family = Struct8; + } + impl _p::Capable for Struct8 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct8>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct8(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct8::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct8::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct8(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct8::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct8::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct8::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct8::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct8::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct8::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct8::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct8::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct8 { + type Reader<'a, T: _p::rpc::Table> = struct8::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct8::Builder<'a, T>; + } + impl _p::ty::Struct for Struct8 { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; + } + impl Struct8 { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u8, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct8::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, u8> { + unsafe { ::accessor(&self.0, &Struct8::F) } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct8::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, u8> { + unsafe { ::accessor(&mut self.0, &Struct8::F) } + } + } + pub mod struct8 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct8< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct8< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct16(T); + impl _p::IntoFamily for Struct16 { + type Family = Struct16; + } + impl _p::Capable for Struct16 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct16>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct16(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct16::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct16::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct16(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct16::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct16::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct16::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct16::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct16::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct16::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct16::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct16::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct16 { + type Reader<'a, T: _p::rpc::Table> = struct16::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct16::Builder<'a, T>; + } + impl _p::ty::Struct for Struct16 { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; + } + impl Struct16 { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u16, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct16::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, u16> { + unsafe { ::accessor(&self.0, &Struct16::F) } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct16::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, u16> { + unsafe { ::accessor(&mut self.0, &Struct16::F) } + } + } + pub mod struct16 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct16< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct16< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct32(T); + impl _p::IntoFamily for Struct32 { + type Family = Struct32; + } + impl _p::Capable for Struct32 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct32>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct32(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct32::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct32::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct32(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct32::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct32::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct32::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct32::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct32::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct32::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct32::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct32::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct32 { + type Reader<'a, T: _p::rpc::Table> = struct32::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct32::Builder<'a, T>; + } + impl _p::ty::Struct for Struct32 { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; + } + impl Struct32 { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u32, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct32::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, u32> { + unsafe { ::accessor(&self.0, &Struct32::F) } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct32::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, u32> { + unsafe { ::accessor(&mut self.0, &Struct32::F) } + } + } + pub mod struct32 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct32< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct32< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct64(T); + impl _p::IntoFamily for Struct64 { + type Family = Struct64; + } + impl _p::Capable for Struct64 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct64>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct64(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct64::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct64::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct64(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct64::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct64::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct64::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct64::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct64::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct64::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct64::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct64::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct64 { + type Reader<'a, T: _p::rpc::Table> = struct64::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct64::Builder<'a, T>; + } + impl _p::ty::Struct for Struct64 { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; + } + impl Struct64 { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u64, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct64::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, u64> { + unsafe { ::accessor(&self.0, &Struct64::F) } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct64::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, u64> { + unsafe { ::accessor(&mut self.0, &Struct64::F) } + } + } + pub mod struct64 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct64< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct64< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct StructP(T); + impl _p::IntoFamily for StructP { + type Family = StructP; + } + impl _p::Capable for StructP { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = StructP>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (StructP(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct_p::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct_p::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + StructP(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct_p::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct_p::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct_p::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct_p::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct_p::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct_p::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct_p::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct_p::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for StructP { + type Reader<'a, T: _p::rpc::Table> = struct_p::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct_p::Builder<'a, T>; + } + impl _p::ty::Struct for StructP { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; + } + impl StructP { + const F: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct_p::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { <_p::Text as _p::field::FieldType>::accessor(&self.0, &StructP::F) } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct_p::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &StructP::F) + } + } + #[inline] + pub fn into_f(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { <_p::Text as _p::field::FieldType>::accessor(self.0, &StructP::F) } + } + } + pub mod struct_p { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::StructP< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::StructP< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct0c(T); + impl _p::IntoFamily for Struct0c { + type Family = Struct0c; + } + impl _p::Capable for Struct0c { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct0c>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct0c(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct0c::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct0c::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct0c(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct0c::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct0c::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct0c::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct0c::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct0c::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct0c::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct0c::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct0c::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct0c { + type Reader<'a, T: _p::rpc::Table> = struct0c::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct0c::Builder<'a, T>; + } + impl _p::ty::Struct for Struct0c { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; + } + impl Struct0c { + const F: _p::Descriptor<()> = (); + const PAD: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct0c::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::accessor(&self.0, &Struct0c::F) } + } + #[inline] + pub fn pad(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Struct0c::PAD) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct0c::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::accessor(&mut self.0, &Struct0c::F) } + } + #[inline] + pub fn pad(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &Struct0c::PAD) + } + } + #[inline] + pub fn into_pad(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Struct0c::PAD) + } + } + } + pub mod struct0c { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct0c< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct0c< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct1c(T); + impl _p::IntoFamily for Struct1c { + type Family = Struct1c; + } + impl _p::Capable for Struct1c { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct1c>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct1c(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct1c::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct1c::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct1c(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct1c::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct1c::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct1c::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct1c::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct1c::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct1c::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct1c::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct1c::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct1c { + type Reader<'a, T: _p::rpc::Table> = struct1c::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct1c::Builder<'a, T>; + } + impl _p::ty::Struct for Struct1c { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; + } + impl Struct1c { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: false, + }; + const PAD: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct1c::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { ::accessor(&self.0, &Struct1c::F) } + } + #[inline] + pub fn pad(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Struct1c::PAD) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct1c::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor(&mut self.0, &Struct1c::F) + } + } + #[inline] + pub fn pad(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &Struct1c::PAD) + } + } + #[inline] + pub fn into_pad(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Struct1c::PAD) + } + } + } + pub mod struct1c { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct1c< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct1c< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct8c(T); + impl _p::IntoFamily for Struct8c { + type Family = Struct8c; + } + impl _p::Capable for Struct8c { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct8c>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct8c(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct8c::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct8c::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct8c(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct8c::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct8c::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct8c::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct8c::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct8c::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct8c::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct8c::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct8c::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct8c { + type Reader<'a, T: _p::rpc::Table> = struct8c::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct8c::Builder<'a, T>; + } + impl _p::ty::Struct for Struct8c { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; + } + impl Struct8c { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u8, + }; + const PAD: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct8c::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, u8> { + unsafe { ::accessor(&self.0, &Struct8c::F) } + } + #[inline] + pub fn pad(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Struct8c::PAD) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct8c::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, u8> { + unsafe { ::accessor(&mut self.0, &Struct8c::F) } + } + #[inline] + pub fn pad(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &Struct8c::PAD) + } + } + #[inline] + pub fn into_pad(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Struct8c::PAD) + } + } + } + pub mod struct8c { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct8c< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct8c< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct16c(T); + impl _p::IntoFamily for Struct16c { + type Family = Struct16c; + } + impl _p::Capable for Struct16c { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct16c>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct16c(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct16c::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct16c::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct16c(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct16c::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct16c::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct16c::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct16c::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct16c::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct16c::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct16c::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct16c::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct16c { + type Reader<'a, T: _p::rpc::Table> = struct16c::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct16c::Builder<'a, T>; + } + impl _p::ty::Struct for Struct16c { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; + } + impl Struct16c { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u16, + }; + const PAD: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct16c::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, u16> { + unsafe { ::accessor(&self.0, &Struct16c::F) } + } + #[inline] + pub fn pad(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Struct16c::PAD) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct16c::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, u16> { + unsafe { + ::accessor(&mut self.0, &Struct16c::F) + } + } + #[inline] + pub fn pad(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Struct16c::PAD, + ) + } + } + #[inline] + pub fn into_pad(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Struct16c::PAD) + } + } + } + pub mod struct16c { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct16c< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct16c< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct32c(T); + impl _p::IntoFamily for Struct32c { + type Family = Struct32c; + } + impl _p::Capable for Struct32c { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct32c>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct32c(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct32c::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct32c::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct32c(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct32c::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct32c::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct32c::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct32c::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct32c::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct32c::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct32c::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct32c::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct32c { + type Reader<'a, T: _p::rpc::Table> = struct32c::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct32c::Builder<'a, T>; + } + impl _p::ty::Struct for Struct32c { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; + } + impl Struct32c { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u32, + }; + const PAD: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct32c::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, u32> { + unsafe { ::accessor(&self.0, &Struct32c::F) } + } + #[inline] + pub fn pad(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Struct32c::PAD) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct32c::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, u32> { + unsafe { + ::accessor(&mut self.0, &Struct32c::F) + } + } + #[inline] + pub fn pad(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Struct32c::PAD, + ) + } + } + #[inline] + pub fn into_pad(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Struct32c::PAD) + } + } + } + pub mod struct32c { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct32c< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct32c< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Struct64c(T); + impl _p::IntoFamily for Struct64c { + type Family = Struct64c; + } + impl _p::Capable for Struct64c { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Struct64c>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Struct64c(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct64c::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct64c::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Struct64c(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct64c::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct64c::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct64c::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct64c::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct64c::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct64c::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct64c::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct64c::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Struct64c { + type Reader<'a, T: _p::rpc::Table> = struct64c::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct64c::Builder<'a, T>; + } + impl _p::ty::Struct for Struct64c { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; + } + impl Struct64c { + const F: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u64, + }; + const PAD: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct64c::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, u64> { + unsafe { ::accessor(&self.0, &Struct64c::F) } + } + #[inline] + pub fn pad(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Struct64c::PAD) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct64c::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, u64> { + unsafe { + ::accessor(&mut self.0, &Struct64c::F) + } + } + #[inline] + pub fn pad(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &Struct64c::PAD, + ) + } + } + #[inline] + pub fn into_pad(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Struct64c::PAD) + } + } + } + pub mod struct64c { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Struct64c< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Struct64c< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct StructPc(T); + impl _p::IntoFamily for StructPc { + type Family = StructPc; + } + impl _p::Capable for StructPc { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = StructPc>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (StructPc(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct_pc::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for struct_pc::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + StructPc(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: struct_pc::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for struct_pc::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for struct_pc::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for struct_pc::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: struct_pc::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for struct_pc::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for struct_pc::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for struct_pc::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for StructPc { + type Reader<'a, T: _p::rpc::Table> = struct_pc::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = struct_pc::Builder<'a, T>; + } + impl _p::ty::Struct for StructPc { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; + } + impl StructPc { + const F: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const PAD: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u64, + }; + } + impl<'p, T: _p::rpc::Table + 'p> struct_pc::Reader<'p, T> { + #[inline] + pub fn f(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &StructPc::F) + } + } + #[inline] + pub fn pad(&self) -> _p::Accessor<'_, 'p, T, u64> { + unsafe { ::accessor(&self.0, &StructPc::PAD) } + } + } + impl<'p, T: _p::rpc::Table + 'p> struct_pc::Builder<'p, T> { + #[inline] + pub fn f(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &StructPc::F) + } + } + #[inline] + pub fn pad(&mut self) -> _p::AccessorMut<'_, 'p, T, u64> { + unsafe { + ::accessor(&mut self.0, &StructPc::PAD) + } + } + #[inline] + pub fn into_f(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { <_p::Text as _p::field::FieldType>::accessor(self.0, &StructPc::F) } + } + } + pub mod struct_pc { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::StructPc< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::StructPc< + _p::StructBuilder<'a, T>, + >; + } +} +#[derive(Clone)] +pub struct TestFieldZeroIsBit(T); +impl _p::IntoFamily for TestFieldZeroIsBit { + type Family = TestFieldZeroIsBit; +} +impl _p::Capable for TestFieldZeroIsBit { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestFieldZeroIsBit>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestFieldZeroIsBit(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_field_zero_is_bit::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_field_zero_is_bit::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestFieldZeroIsBit(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_field_zero_is_bit::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_field_zero_is_bit::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_field_zero_is_bit::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_field_zero_is_bit::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_field_zero_is_bit::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_field_zero_is_bit::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_field_zero_is_bit::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_field_zero_is_bit::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestFieldZeroIsBit { + type Reader<'a, T: _p::rpc::Table> = test_field_zero_is_bit::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_field_zero_is_bit::Builder<'a, T>; +} +impl _p::ty::Struct for TestFieldZeroIsBit { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; +} +impl TestFieldZeroIsBit { + const BIT: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: false, + }; + const SECOND_BIT: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: true, + }; + const THIRD_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: 123u8, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_field_zero_is_bit::Reader<'p, T> { + #[inline] + pub fn bit(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { + ::accessor(&self.0, &TestFieldZeroIsBit::BIT) + } + } + #[inline] + pub fn second_bit(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { + ::accessor( + &self.0, + &TestFieldZeroIsBit::SECOND_BIT, + ) + } + } + #[inline] + pub fn third_field(&self) -> _p::Accessor<'_, 'p, T, u8> { + unsafe { + ::accessor( + &self.0, + &TestFieldZeroIsBit::THIRD_FIELD, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_field_zero_is_bit::Builder<'p, T> { + #[inline] + pub fn bit(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor( + &mut self.0, + &TestFieldZeroIsBit::BIT, + ) + } + } + #[inline] + pub fn second_bit(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor( + &mut self.0, + &TestFieldZeroIsBit::SECOND_BIT, + ) + } + } + #[inline] + pub fn third_field(&mut self) -> _p::AccessorMut<'_, 'p, T, u8> { + unsafe { + ::accessor( + &mut self.0, + &TestFieldZeroIsBit::THIRD_FIELD, + ) + } + } +} +pub mod test_field_zero_is_bit { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestFieldZeroIsBit< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestFieldZeroIsBit< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestListDefaults(T); +impl _p::IntoFamily for TestListDefaults { + type Family = TestListDefaults; +} +impl _p::Capable for TestListDefaults { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestListDefaults>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestListDefaults(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_list_defaults::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_list_defaults::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestListDefaults(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_list_defaults::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_list_defaults::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_list_defaults::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_list_defaults::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_list_defaults::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_list_defaults::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_list_defaults::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_list_defaults::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestListDefaults { + type Reader<'a, T: _p::rpc::Table> = test_list_defaults::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_list_defaults::Builder<'a, T>; +} +impl _p::ty::Struct for TestListDefaults { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; +} +impl TestListDefaults { + const LISTS: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([37u8, 0u8, 0u8, 0u8, 7u8, 0u8, 0u8, 0u8]), + _p::Word([37u8, 0u8, 0u8, 0u8, 39u8, 0u8, 0u8, 0u8]), + _p::Word([53u8, 0u8, 0u8, 0u8, 23u8, 0u8, 0u8, 0u8]), + _p::Word([61u8, 0u8, 0u8, 0u8, 23u8, 0u8, 0u8, 0u8]), + _p::Word([69u8, 0u8, 0u8, 0u8, 23u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 23u8, 0u8, 0u8, 0u8]), + _p::Word([85u8, 0u8, 0u8, 0u8, 23u8, 0u8, 0u8, 0u8]), + _p::Word([101u8, 0u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([125u8, 0u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([173u8, 0u8, 0u8, 0u8, 22u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([16u8, 0u8, 0u8, 0u8, 1u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 0u8, 0u8]), + _p::Word([123u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([45u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 0u8, 0u8]), + _p::Word([57u8, 48u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 26u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 0u8, 0u8]), + _p::Word([21u8, 205u8, 91u8, 7u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 56u8, 251u8, 13u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 0u8, 0u8]), + _p::Word([192u8, 186u8, 138u8, 60u8, 213u8, 98u8, 4u8, 0u8]), + _p::Word([135u8, 75u8, 170u8, 237u8, 97u8, 85u8, 8u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 114u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 28u8, 0u8, 0u8, 0u8]), + _p::Word([13u8, 0u8, 0u8, 0u8, 20u8, 0u8, 0u8, 0u8]), + _p::Word([13u8, 0u8, 0u8, 0u8, 12u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 2u8, 0u8, 0u8, 0u8]), + _p::Word([3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 5u8, 0u8, 0u8, 0u8]), + _p::Word([242u8, 79u8, 188u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 22u8, 0u8, 0u8, 0u8]), + _p::Word([21u8, 0u8, 0u8, 0u8, 14u8, 0u8, 0u8, 0u8]), + _p::Word([25u8, 0u8, 0u8, 0u8, 22u8, 0u8, 0u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 114u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 122u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([99u8, 111u8, 114u8, 103u8, 101u8, 0u8, 0u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 167u8, 1u8, 0u8, 0u8]), + _p::Word([213u8, 0u8, 0u8, 0u8, 215u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 123u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 200u8, 1u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 21u8, 3u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 10u16, + }, + ) + }), + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_list_defaults::Reader<'p, T> { + #[inline] + pub fn lists(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestLists, + > as _p::field::FieldType>::accessor(&self.0, &TestListDefaults::LISTS) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_list_defaults::Builder<'p, T> { + #[inline] + pub fn lists(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestLists, + > as _p::field::FieldType>::accessor(&mut self.0, &TestListDefaults::LISTS) + } + } + #[inline] + pub fn into_lists(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestLists, + > as _p::field::FieldType>::accessor(self.0, &TestListDefaults::LISTS) + } + } +} +pub mod test_list_defaults { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestListDefaults< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestListDefaults< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestLateUnion(T); +impl _p::IntoFamily for TestLateUnion { + type Family = TestLateUnion; +} +impl _p::Capable for TestLateUnion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestLateUnion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestLateUnion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_late_union::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_late_union::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestLateUnion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_late_union::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_late_union::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_late_union::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_late_union::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_late_union::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_late_union::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_late_union::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_late_union::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestLateUnion { + type Reader<'a, T: _p::rpc::Table> = test_late_union::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_late_union::Builder<'a, T>; +} +impl _p::ty::Struct for TestLateUnion { + const SIZE: _p::StructSize = _p::StructSize { + data: 3u16, + ptrs: 3u16, + }; +} +impl TestLateUnion { + const FOO: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0i32, + }; + const BAR: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const BAZ: _p::Descriptor = _p::Descriptor:: { + slot: 2u32, + default: 0i16, + }; + const THE_UNION: _p::Descriptor<_p::Group> = (); + const ANOTHER_UNION: _p::Descriptor<_p::Group> = (); +} +impl<'p, T: _p::rpc::Table + 'p> test_late_union::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, i32> { + unsafe { ::accessor(&self.0, &TestLateUnion::FOO) } + } + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestLateUnion::BAR) + } + } + #[inline] + pub fn baz(&self) -> _p::Accessor<'_, 'p, T, i16> { + unsafe { ::accessor(&self.0, &TestLateUnion::BAZ) } + } + #[inline] + pub fn the_union( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_late_union::TheUnion, + > as _p::field::FieldType>::accessor(&self.0, &TestLateUnion::THE_UNION) + } + } + #[inline] + pub fn another_union( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_late_union::AnotherUnion, + > as _p::field::FieldType>::accessor(&self.0, &TestLateUnion::ANOTHER_UNION) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_late_union::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, i32> { + unsafe { + ::accessor(&mut self.0, &TestLateUnion::FOO) + } + } + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestLateUnion::BAR, + ) + } + } + #[inline] + pub fn baz(&mut self) -> _p::AccessorMut<'_, 'p, T, i16> { + unsafe { + ::accessor(&mut self.0, &TestLateUnion::BAZ) + } + } + #[inline] + pub fn the_union( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_late_union::TheUnion, + > as _p::field::FieldType>::accessor(&mut self.0, &TestLateUnion::THE_UNION) + } + } + #[inline] + pub fn another_union( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_late_union::AnotherUnion, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestLateUnion::ANOTHER_UNION, + ) + } + } + #[inline] + pub fn into_bar(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestLateUnion::BAR) + } + } + #[inline] + pub fn into_the_union( + self, + ) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_late_union::TheUnion, + > as _p::field::FieldType>::accessor(self.0, &TestLateUnion::THE_UNION) + } + } + #[inline] + pub fn into_another_union( + self, + ) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_late_union::AnotherUnion, + > as _p::field::FieldType>::accessor(self.0, &TestLateUnion::ANOTHER_UNION) + } + } +} +pub mod test_late_union { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestLateUnion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestLateUnion< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct TheUnion(T); + impl _p::IntoFamily for TheUnion { + type Family = TheUnion; + } + impl _p::Capable for TheUnion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TheUnion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TheUnion(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for the_union::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for the_union::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TheUnion(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: the_union::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for the_union::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for the_union::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for the_union::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: the_union::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for the_union::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for the_union::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for the_union::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for TheUnion { + type Reader<'a, T: _p::rpc::Table> = the_union::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = the_union::Builder<'a, T>; + } + impl _p::FieldGroup for TheUnion { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(3usize, 0); + <_p::Text as _p::field::FieldType>::clear(s, &TheUnion::QUX.field); + } + } + impl TheUnion { + const QUX: _p::VariantDescriptor<_p::Text> = _p::VariantDescriptor::<_p::Text> { + variant: _p::VariantInfo { + slot: 3u32, + case: 0u16, + }, + field: _p::Descriptor::<_p::Text> { + slot: 1u32, + default: ::core::option::Option::None, + }, + }; + const CORGE: _p::VariantDescriptor<_p::List> = _p::VariantDescriptor::< + _p::List, + > { + variant: _p::VariantInfo { + slot: 3u32, + case: 1u16, + }, + field: _p::Descriptor::<_p::List> { + slot: 1u32, + default: ::core::option::Option::None, + }, + }; + const GRAULT: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 3u32, + case: 2u16, + }, + field: _p::Descriptor:: { + slot: 2u32, + default: 0.0f32, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> the_union::Reader<'p, T> { + #[inline] + pub fn qux(&self) -> _p::Variant<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&self.0, &TheUnion::QUX) + } + } + #[inline] + pub fn corge(&self) -> _p::Variant<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i32, + > as _p::field::FieldType>::variant(&self.0, &TheUnion::CORGE) + } + } + #[inline] + pub fn grault(&self) -> _p::Variant<'_, 'p, T, f32> { + unsafe { ::variant(&self.0, &TheUnion::GRAULT) } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> the_union::Builder<'p, T> { + #[inline] + pub fn qux(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&mut self.0, &TheUnion::QUX) + } + } + #[inline] + pub fn corge(&mut self) -> _p::VariantMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i32, + > as _p::field::FieldType>::variant(&mut self.0, &TheUnion::CORGE) + } + } + #[inline] + pub fn grault(&mut self) -> _p::VariantMut<'_, 'p, T, f32> { + unsafe { + ::variant(&mut self.0, &TheUnion::GRAULT) + } + } + #[inline] + pub fn into_qux(self) -> _p::VariantOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(self.0, &TheUnion::QUX) + } + } + #[inline] + pub fn into_corge(self) -> _p::VariantOwned<'p, T, _p::List> { + unsafe { + <_p::List< + i32, + > as _p::field::FieldType>::variant(self.0, &TheUnion::CORGE) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod the_union { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TheUnion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TheUnion< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Qux(_p::ViewOf), + Corge(_p::ViewOf>), + Grault(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(3usize); + match tag { + 0u16 => { + Ok( + Which::Qux( + <_p::Text as _p::field::FieldType>::accessor( + &repr.0, + &super::TheUnion::QUX.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Corge( + <_p::List< + i32, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::TheUnion::CORGE.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Grault( + ::accessor( + &repr.0, + &super::TheUnion::GRAULT.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(3usize); + match tag { + 0u16 => { + Ok( + Which::Qux( + <_p::Text as _p::field::FieldType>::accessor( + &mut repr.0, + &super::TheUnion::QUX.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Corge( + <_p::List< + i32, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::TheUnion::CORGE.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Grault( + ::accessor( + &mut repr.0, + &super::TheUnion::GRAULT.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + } + #[derive(Clone)] + pub struct AnotherUnion(T); + impl _p::IntoFamily for AnotherUnion { + type Family = AnotherUnion; + } + impl _p::Capable for AnotherUnion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = AnotherUnion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (AnotherUnion(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for another_union::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for another_union::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + AnotherUnion(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: another_union::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for another_union::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for another_union::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for another_union::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: another_union::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for another_union::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for another_union::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for another_union::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for AnotherUnion { + type Reader<'a, T: _p::rpc::Table> = another_union::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = another_union::Builder<'a, T>; + } + impl _p::FieldGroup for AnotherUnion { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(6usize, 0); + <_p::Text as _p::field::FieldType>::clear(s, &AnotherUnion::QUX.field); + } + } + impl AnotherUnion { + const QUX: _p::VariantDescriptor<_p::Text> = _p::VariantDescriptor::<_p::Text> { + variant: _p::VariantInfo { + slot: 6u32, + case: 0u16, + }, + field: _p::Descriptor::<_p::Text> { + slot: 2u32, + default: ::core::option::Option::None, + }, + }; + const CORGE: _p::VariantDescriptor<_p::List> = _p::VariantDescriptor::< + _p::List, + > { + variant: _p::VariantInfo { + slot: 6u32, + case: 1u16, + }, + field: _p::Descriptor::<_p::List> { + slot: 2u32, + default: ::core::option::Option::None, + }, + }; + const GRAULT: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 6u32, + case: 2u16, + }, + field: _p::Descriptor:: { + slot: 4u32, + default: 0.0f32, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> another_union::Reader<'p, T> { + #[inline] + pub fn qux(&self) -> _p::Variant<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(&self.0, &AnotherUnion::QUX) + } + } + #[inline] + pub fn corge(&self) -> _p::Variant<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i32, + > as _p::field::FieldType>::variant(&self.0, &AnotherUnion::CORGE) + } + } + #[inline] + pub fn grault(&self) -> _p::Variant<'_, 'p, T, f32> { + unsafe { + ::variant(&self.0, &AnotherUnion::GRAULT) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> another_union::Builder<'p, T> { + #[inline] + pub fn qux(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant( + &mut self.0, + &AnotherUnion::QUX, + ) + } + } + #[inline] + pub fn corge(&mut self) -> _p::VariantMut<'_, 'p, T, _p::List> { + unsafe { + <_p::List< + i32, + > as _p::field::FieldType>::variant(&mut self.0, &AnotherUnion::CORGE) + } + } + #[inline] + pub fn grault(&mut self) -> _p::VariantMut<'_, 'p, T, f32> { + unsafe { + ::variant( + &mut self.0, + &AnotherUnion::GRAULT, + ) + } + } + #[inline] + pub fn into_qux(self) -> _p::VariantOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::variant(self.0, &AnotherUnion::QUX) + } + } + #[inline] + pub fn into_corge(self) -> _p::VariantOwned<'p, T, _p::List> { + unsafe { + <_p::List< + i32, + > as _p::field::FieldType>::variant(self.0, &AnotherUnion::CORGE) + } + } + #[inline] + pub fn which( + &mut self, + ) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod another_union { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::AnotherUnion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::AnotherUnion< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Qux(_p::ViewOf), + Corge(_p::ViewOf>), + Grault(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(6usize); + match tag { + 0u16 => { + Ok( + Which::Qux( + <_p::Text as _p::field::FieldType>::accessor( + &repr.0, + &super::AnotherUnion::QUX.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Corge( + <_p::List< + i32, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::AnotherUnion::CORGE.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Grault( + ::accessor( + &repr.0, + &super::AnotherUnion::GRAULT.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(6usize); + match tag { + 0u16 => { + Ok( + Which::Qux( + <_p::Text as _p::field::FieldType>::accessor( + &mut repr.0, + &super::AnotherUnion::QUX.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Corge( + <_p::List< + i32, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::AnotherUnion::CORGE.field, + ), + ), + ) + } + 2u16 => { + Ok( + Which::Grault( + ::accessor( + &mut repr.0, + &super::AnotherUnion::GRAULT.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + } +} +#[derive(Clone)] +pub struct TestOldVersion(T); +impl _p::IntoFamily for TestOldVersion { + type Family = TestOldVersion; +} +impl _p::Capable for TestOldVersion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestOldVersion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestOldVersion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_old_version::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_old_version::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestOldVersion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_old_version::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_old_version::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_old_version::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_old_version::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_old_version::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_old_version::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_old_version::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_old_version::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestOldVersion { + type Reader<'a, T: _p::rpc::Table> = test_old_version::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_old_version::Builder<'a, T>; +} +impl _p::ty::Struct for TestOldVersion { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 2u16, + }; +} +impl TestOldVersion { + const OLD1: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0i64, + }; + const OLD2: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const OLD3: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_old_version::Reader<'p, T> { + #[inline] + pub fn old1(&self) -> _p::Accessor<'_, 'p, T, i64> { + unsafe { + ::accessor(&self.0, &TestOldVersion::OLD1) + } + } + #[inline] + pub fn old2(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestOldVersion::OLD2) + } + } + #[inline] + pub fn old3(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestOldVersion, + > as _p::field::FieldType>::accessor(&self.0, &TestOldVersion::OLD3) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_old_version::Builder<'p, T> { + #[inline] + pub fn old1(&mut self) -> _p::AccessorMut<'_, 'p, T, i64> { + unsafe { + ::accessor(&mut self.0, &TestOldVersion::OLD1) + } + } + #[inline] + pub fn old2(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestOldVersion::OLD2, + ) + } + } + #[inline] + pub fn old3(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestOldVersion, + > as _p::field::FieldType>::accessor(&mut self.0, &TestOldVersion::OLD3) + } + } + #[inline] + pub fn into_old2(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestOldVersion::OLD2) + } + } + #[inline] + pub fn into_old3(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestOldVersion, + > as _p::field::FieldType>::accessor(self.0, &TestOldVersion::OLD3) + } + } +} +pub mod test_old_version { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestOldVersion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestOldVersion< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestNewVersion(T); +impl _p::IntoFamily for TestNewVersion { + type Family = TestNewVersion; +} +impl _p::Capable for TestNewVersion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestNewVersion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestNewVersion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_new_version::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_new_version::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestNewVersion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_new_version::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_new_version::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_new_version::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_new_version::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_new_version::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_new_version::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_new_version::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_new_version::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestNewVersion { + type Reader<'a, T: _p::rpc::Table> = test_new_version::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_new_version::Builder<'a, T>; +} +impl _p::ty::Struct for TestNewVersion { + const SIZE: _p::StructSize = _p::StructSize { + data: 2u16, + ptrs: 3u16, + }; +} +impl TestNewVersion { + const OLD1: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0i64, + }; + const OLD2: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const OLD3: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; + const NEW1: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: 987i64, + }; + const NEW2: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 2u32, + default: ::core::option::Option::Some(_p::text::Reader::from_slice(b"baz\0")), + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_new_version::Reader<'p, T> { + #[inline] + pub fn old1(&self) -> _p::Accessor<'_, 'p, T, i64> { + unsafe { + ::accessor(&self.0, &TestNewVersion::OLD1) + } + } + #[inline] + pub fn old2(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestNewVersion::OLD2) + } + } + #[inline] + pub fn old3(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestNewVersion, + > as _p::field::FieldType>::accessor(&self.0, &TestNewVersion::OLD3) + } + } + #[inline] + pub fn new1(&self) -> _p::Accessor<'_, 'p, T, i64> { + unsafe { + ::accessor(&self.0, &TestNewVersion::NEW1) + } + } + #[inline] + pub fn new2(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TestNewVersion::NEW2) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_new_version::Builder<'p, T> { + #[inline] + pub fn old1(&mut self) -> _p::AccessorMut<'_, 'p, T, i64> { + unsafe { + ::accessor(&mut self.0, &TestNewVersion::OLD1) + } + } + #[inline] + pub fn old2(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestNewVersion::OLD2, + ) + } + } + #[inline] + pub fn old3(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestNewVersion, + > as _p::field::FieldType>::accessor(&mut self.0, &TestNewVersion::OLD3) + } + } + #[inline] + pub fn new1(&mut self) -> _p::AccessorMut<'_, 'p, T, i64> { + unsafe { + ::accessor(&mut self.0, &TestNewVersion::NEW1) + } + } + #[inline] + pub fn new2(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestNewVersion::NEW2, + ) + } + } + #[inline] + pub fn into_old2(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestNewVersion::OLD2) + } + } + #[inline] + pub fn into_old3(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestNewVersion, + > as _p::field::FieldType>::accessor(self.0, &TestNewVersion::OLD3) + } + } + #[inline] + pub fn into_new2(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TestNewVersion::NEW2) + } + } +} +pub mod test_new_version { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestNewVersion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestNewVersion< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestOldUnionVersion(T); +impl _p::IntoFamily for TestOldUnionVersion { + type Family = TestOldUnionVersion; +} +impl _p::Capable for TestOldUnionVersion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestOldUnionVersion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestOldUnionVersion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_old_union_version::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_old_union_version::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestOldUnionVersion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_old_union_version::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_old_union_version::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_old_union_version::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_old_union_version::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_old_union_version::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_old_union_version::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_old_union_version::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_old_union_version::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestOldUnionVersion { + type Reader<'a, T: _p::rpc::Table> = test_old_union_version::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_old_union_version::Builder<'a, T>; +} +impl _p::ty::Struct for TestOldUnionVersion { + const SIZE: _p::StructSize = _p::StructSize { + data: 2u16, + ptrs: 0u16, + }; +} +impl TestOldUnionVersion { + const A: _p::VariantDescriptor<()> = _p::VariantDescriptor::<()> { + variant: _p::VariantInfo { + slot: 0u32, + case: 0u16, + }, + field: (), + }; + const B: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 1u32, + default: 0u64, + }, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_old_union_version::Reader<'p, T> { + #[inline] + pub fn a(&self) -> _p::Variant<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::variant(&self.0, &TestOldUnionVersion::A) + } + } + #[inline] + pub fn b(&self) -> _p::Variant<'_, 'p, T, u64> { + unsafe { + ::variant(&self.0, &TestOldUnionVersion::B) + } + } + #[inline] + pub fn which( + &self, + ) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_old_union_version::Builder<'p, T> { + #[inline] + pub fn a(&mut self) -> _p::VariantMut<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::variant(&mut self.0, &TestOldUnionVersion::A) + } + } + #[inline] + pub fn b(&mut self) -> _p::VariantMut<'_, 'p, T, u64> { + unsafe { + ::variant(&mut self.0, &TestOldUnionVersion::B) + } + } + #[inline] + pub fn which( + &mut self, + ) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +pub mod test_old_union_version { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestOldUnionVersion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestOldUnionVersion< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + A(_p::ViewOf), + B(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get(repr: &'b Reader<'p, T>) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::A( + <() as _p::field::FieldType>::accessor( + &repr.0, + &super::TestOldUnionVersion::A.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::B( + ::accessor( + &repr.0, + &super::TestOldUnionVersion::B.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::A( + <() as _p::field::FieldType>::accessor( + &mut repr.0, + &super::TestOldUnionVersion::A.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::B( + ::accessor( + &mut repr.0, + &super::TestOldUnionVersion::B.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } +} +#[derive(Clone)] +pub struct TestNewUnionVersion(T); +impl _p::IntoFamily for TestNewUnionVersion { + type Family = TestNewUnionVersion; +} +impl _p::Capable for TestNewUnionVersion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestNewUnionVersion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestNewUnionVersion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_new_union_version::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_new_union_version::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestNewUnionVersion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_new_union_version::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_new_union_version::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_new_union_version::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_new_union_version::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_new_union_version::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_new_union_version::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_new_union_version::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_new_union_version::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestNewUnionVersion { + type Reader<'a, T: _p::rpc::Table> = test_new_union_version::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_new_union_version::Builder<'a, T>; +} +impl _p::ty::Struct for TestNewUnionVersion { + const SIZE: _p::StructSize = _p::StructSize { + data: 3u16, + ptrs: 0u16, + }; +} +impl TestNewUnionVersion { + const A: _p::VariantDescriptor<_p::Group> = _p::VariantDescriptor::< + _p::Group, + > { + variant: _p::VariantInfo { + slot: 0u32, + case: 0u16, + }, + field: (), + }; + const B: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 0u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 1u32, + default: 0u64, + }, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_new_union_version::Reader<'p, T> { + #[inline] + pub fn a(&self) -> _p::Variant<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_new_union_version::A, + > as _p::field::FieldType>::variant(&self.0, &TestNewUnionVersion::A) + } + } + #[inline] + pub fn b(&self) -> _p::Variant<'_, 'p, T, u64> { + unsafe { + ::variant(&self.0, &TestNewUnionVersion::B) + } + } + #[inline] + pub fn which( + &self, + ) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_new_union_version::Builder<'p, T> { + #[inline] + pub fn a( + &mut self, + ) -> _p::VariantMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_new_union_version::A, + > as _p::field::FieldType>::variant(&mut self.0, &TestNewUnionVersion::A) + } + } + #[inline] + pub fn b(&mut self) -> _p::VariantMut<'_, 'p, T, u64> { + unsafe { + ::variant(&mut self.0, &TestNewUnionVersion::B) + } + } + #[inline] + pub fn into_a( + self, + ) -> _p::VariantOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_new_union_version::A, + > as _p::field::FieldType>::variant(self.0, &TestNewUnionVersion::A) + } + } + #[inline] + pub fn which( + &mut self, + ) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +pub mod test_new_union_version { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestNewUnionVersion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestNewUnionVersion< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + A(_p::ViewOf>), + B(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get(repr: &'b Reader<'p, T>) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::A( + <_p::Group< + A, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::TestNewUnionVersion::A.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::B( + ::accessor( + &repr.0, + &super::TestNewUnionVersion::B.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::A( + <_p::Group< + A, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::TestNewUnionVersion::A.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::B( + ::accessor( + &mut repr.0, + &super::TestNewUnionVersion::B.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + #[derive(Clone)] + pub struct A(T); + impl _p::IntoFamily for A { + type Family = A; + } + impl _p::Capable for A { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = A>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (A(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for a::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for a::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + A(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: a::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for a::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for a::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for a::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: a::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for a::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for a::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for a::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for A { + type Reader<'a, T: _p::rpc::Table> = a::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = a::Builder<'a, T>; + } + impl _p::FieldGroup for A { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(4usize, 0); + <() as _p::field::FieldType>::clear(s, &A::A0.field); + } + } + impl A { + const A0: _p::VariantDescriptor<()> = _p::VariantDescriptor::<()> { + variant: _p::VariantInfo { + slot: 4u32, + case: 0u16, + }, + field: (), + }; + const A1: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 4u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 2u32, + default: 0u64, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> a::Reader<'p, T> { + #[inline] + pub fn a0(&self) -> _p::Variant<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::variant(&self.0, &A::A0) } + } + #[inline] + pub fn a1(&self) -> _p::Variant<'_, 'p, T, u64> { + unsafe { ::variant(&self.0, &A::A1) } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> a::Builder<'p, T> { + #[inline] + pub fn a0(&mut self) -> _p::VariantMut<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::variant(&mut self.0, &A::A0) } + } + #[inline] + pub fn a1(&mut self) -> _p::VariantMut<'_, 'p, T, u64> { + unsafe { ::variant(&mut self.0, &A::A1) } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod a { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::A<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::A<_p::StructBuilder<'a, T>>; + pub enum Which { + A0(_p::ViewOf), + A1(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(4usize); + match tag { + 0u16 => { + Ok( + Which::A0( + <() as _p::field::FieldType>::accessor( + &repr.0, + &super::A::A0.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::A1( + ::accessor( + &repr.0, + &super::A::A1.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(4usize); + match tag { + 0u16 => { + Ok( + Which::A0( + <() as _p::field::FieldType>::accessor( + &mut repr.0, + &super::A::A0.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::A1( + ::accessor( + &mut repr.0, + &super::A::A1.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + } +} +#[derive(Clone)] +pub struct TestStructUnion(T); +impl _p::IntoFamily for TestStructUnion { + type Family = TestStructUnion; +} +impl _p::Capable for TestStructUnion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestStructUnion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestStructUnion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_struct_union::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_struct_union::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestStructUnion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_struct_union::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_struct_union::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_struct_union::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_struct_union::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_struct_union::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_struct_union::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_struct_union::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_struct_union::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestStructUnion { + type Reader<'a, T: _p::rpc::Table> = test_struct_union::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_struct_union::Builder<'a, T>; +} +impl _p::ty::Struct for TestStructUnion { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; +} +impl TestStructUnion { + const UN: _p::Descriptor<_p::Group> = (); +} +impl<'p, T: _p::rpc::Table + 'p> test_struct_union::Reader<'p, T> { + #[inline] + pub fn un(&self) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_struct_union::Un, + > as _p::field::FieldType>::accessor(&self.0, &TestStructUnion::UN) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_struct_union::Builder<'p, T> { + #[inline] + pub fn un( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_struct_union::Un, + > as _p::field::FieldType>::accessor(&mut self.0, &TestStructUnion::UN) + } + } + #[inline] + pub fn into_un(self) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_struct_union::Un, + > as _p::field::FieldType>::accessor(self.0, &TestStructUnion::UN) + } + } +} +pub mod test_struct_union { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestStructUnion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestStructUnion< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct SomeStruct(T); + impl _p::IntoFamily for SomeStruct { + type Family = SomeStruct; + } + impl _p::Capable for SomeStruct { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = SomeStruct>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (SomeStruct(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for some_struct::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for some_struct::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + SomeStruct(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: some_struct::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for some_struct::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for some_struct::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for some_struct::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: some_struct::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for some_struct::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for some_struct::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for some_struct::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for SomeStruct { + type Reader<'a, T: _p::rpc::Table> = some_struct::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = some_struct::Builder<'a, T>; + } + impl _p::ty::Struct for SomeStruct { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 2u16, + }; + } + impl SomeStruct { + const SOME_TEXT: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const MORE_TEXT: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 1u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> some_struct::Reader<'p, T> { + #[inline] + pub fn some_text(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &SomeStruct::SOME_TEXT, + ) + } + } + #[inline] + pub fn more_text(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &SomeStruct::MORE_TEXT, + ) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> some_struct::Builder<'p, T> { + #[inline] + pub fn some_text(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &SomeStruct::SOME_TEXT, + ) + } + } + #[inline] + pub fn more_text(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &SomeStruct::MORE_TEXT, + ) + } + } + #[inline] + pub fn into_some_text(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + self.0, + &SomeStruct::SOME_TEXT, + ) + } + } + #[inline] + pub fn into_more_text(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + self.0, + &SomeStruct::MORE_TEXT, + ) + } + } + } + pub mod some_struct { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::SomeStruct< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::SomeStruct< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Un(T); + impl _p::IntoFamily for Un { + type Family = Un; + } + impl _p::Capable for Un { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Un>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Un(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for un::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for un::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Un(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: un::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for un::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for un::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for un::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: un::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for un::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for un::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for un::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Un { + type Reader<'a, T: _p::rpc::Table> = un::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = un::Builder<'a, T>; + } + impl _p::FieldGroup for Un { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(0usize, 0); + <_p::Struct< + SomeStruct, + > as _p::field::FieldType>::clear(s, &Un::STRUCT.field); + } + } + impl Un { + const STRUCT: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< + _p::Struct, + > { + variant: _p::VariantInfo { + slot: 0u32, + case: 0u16, + }, + field: _p::Descriptor::<_p::Struct> { + slot: 0u32, + default: ::core::option::Option::None, + }, + }; + const OBJECT: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< + _p::Struct, + > { + variant: _p::VariantInfo { + slot: 0u32, + case: 1u16, + }, + field: _p::Descriptor::<_p::Struct> { + slot: 0u32, + default: ::core::option::Option::None, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> un::Reader<'p, T> { + #[inline] + pub fn r#struct(&self) -> _p::Variant<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + SomeStruct, + > as _p::field::FieldType>::variant(&self.0, &Un::STRUCT) + } + } + #[inline] + pub fn object( + &self, + ) -> _p::Variant<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + super::TestAnyPointer, + > as _p::field::FieldType>::variant(&self.0, &Un::OBJECT) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> un::Builder<'p, T> { + #[inline] + pub fn r#struct(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + SomeStruct, + > as _p::field::FieldType>::variant(&mut self.0, &Un::STRUCT) + } + } + #[inline] + pub fn object( + &mut self, + ) -> _p::VariantMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + super::TestAnyPointer, + > as _p::field::FieldType>::variant(&mut self.0, &Un::OBJECT) + } + } + #[inline] + pub fn into_struct(self) -> _p::VariantOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + SomeStruct, + > as _p::field::FieldType>::variant(self.0, &Un::STRUCT) + } + } + #[inline] + pub fn into_object( + self, + ) -> _p::VariantOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + super::TestAnyPointer, + > as _p::field::FieldType>::variant(self.0, &Un::OBJECT) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod un { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Un<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Un<_p::StructBuilder<'a, T>>; + pub enum Which { + Struct(_p::ViewOf>), + Object(_p::ViewOf>), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::Struct( + <_p::Struct< + super::SomeStruct, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::Un::STRUCT.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Object( + <_p::Struct< + __file::TestAnyPointer, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::Un::OBJECT.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::Struct( + <_p::Struct< + super::SomeStruct, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Un::STRUCT.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Object( + <_p::Struct< + __file::TestAnyPointer, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::Un::OBJECT.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + } +} +#[derive(Clone)] +pub struct TestPrintInlineStructs(T); +impl _p::IntoFamily for TestPrintInlineStructs { + type Family = TestPrintInlineStructs; +} +impl _p::Capable for TestPrintInlineStructs { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestPrintInlineStructs>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestPrintInlineStructs(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_print_inline_structs::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_print_inline_structs::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestPrintInlineStructs(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_print_inline_structs::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_print_inline_structs::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_print_inline_structs::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_print_inline_structs::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl< + 'a, + T: _p::rpc::Table, +> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_print_inline_structs::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_print_inline_structs::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_print_inline_structs::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_print_inline_structs::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestPrintInlineStructs { + type Reader<'a, T: _p::rpc::Table> = test_print_inline_structs::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_print_inline_structs::Builder<'a, T>; +} +impl _p::ty::Struct for TestPrintInlineStructs { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 2u16, + }; +} +impl TestPrintInlineStructs { + const SOME_TEXT: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const STRUCT_LIST: _p::Descriptor< + _p::List<_p::Struct>, + > = _p::Descriptor::<_p::List<_p::Struct>> { + slot: 1u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_print_inline_structs::Reader<'p, T> { + #[inline] + pub fn some_text(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &TestPrintInlineStructs::SOME_TEXT, + ) + } + } + #[inline] + pub fn struct_list( + &self, + ) -> _p::Accessor< + '_, + 'p, + T, + _p::List<_p::Struct>, + > { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor( + &self.0, + &TestPrintInlineStructs::STRUCT_LIST, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_print_inline_structs::Builder<'p, T> { + #[inline] + pub fn some_text(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestPrintInlineStructs::SOME_TEXT, + ) + } + } + #[inline] + pub fn struct_list( + &mut self, + ) -> _p::AccessorMut< + '_, + 'p, + T, + _p::List<_p::Struct>, + > { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestPrintInlineStructs::STRUCT_LIST, + ) + } + } + #[inline] + pub fn into_some_text(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + self.0, + &TestPrintInlineStructs::SOME_TEXT, + ) + } + } + #[inline] + pub fn into_struct_list( + self, + ) -> _p::AccessorOwned< + 'p, + T, + _p::List<_p::Struct>, + > { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor( + self.0, + &TestPrintInlineStructs::STRUCT_LIST, + ) + } + } +} +pub mod test_print_inline_structs { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestPrintInlineStructs< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestPrintInlineStructs< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct InlineStruct(T); + impl _p::IntoFamily for InlineStruct { + type Family = InlineStruct; + } + impl _p::Capable for InlineStruct { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = InlineStruct>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (InlineStruct(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for inline_struct::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for inline_struct::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + InlineStruct(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: inline_struct::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for inline_struct::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for inline_struct::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for inline_struct::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: inline_struct::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for inline_struct::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for inline_struct::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for inline_struct::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for InlineStruct { + type Reader<'a, T: _p::rpc::Table> = inline_struct::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = inline_struct::Builder<'a, T>; + } + impl _p::ty::Struct for InlineStruct { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; + } + impl InlineStruct { + const INT32_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0i32, + }; + const TEXT_FIELD: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> inline_struct::Reader<'p, T> { + #[inline] + pub fn int32_field(&self) -> _p::Accessor<'_, 'p, T, i32> { + unsafe { + ::accessor( + &self.0, + &InlineStruct::INT32_FIELD, + ) + } + } + #[inline] + pub fn text_field(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &InlineStruct::TEXT_FIELD, + ) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> inline_struct::Builder<'p, T> { + #[inline] + pub fn int32_field(&mut self) -> _p::AccessorMut<'_, 'p, T, i32> { + unsafe { + ::accessor( + &mut self.0, + &InlineStruct::INT32_FIELD, + ) + } + } + #[inline] + pub fn text_field(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &InlineStruct::TEXT_FIELD, + ) + } + } + #[inline] + pub fn into_text_field(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + self.0, + &InlineStruct::TEXT_FIELD, + ) + } + } + } + pub mod inline_struct { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::InlineStruct< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::InlineStruct< + _p::StructBuilder<'a, T>, + >; + } +} +#[derive(Clone)] +pub struct TestWholeFloatDefault(T); +impl _p::IntoFamily for TestWholeFloatDefault { + type Family = TestWholeFloatDefault; +} +impl _p::Capable for TestWholeFloatDefault { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestWholeFloatDefault>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestWholeFloatDefault(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_whole_float_default::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_whole_float_default::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestWholeFloatDefault(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_whole_float_default::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_whole_float_default::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_whole_float_default::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_whole_float_default::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_whole_float_default::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_whole_float_default::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_whole_float_default::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_whole_float_default::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestWholeFloatDefault { + type Reader<'a, T: _p::rpc::Table> = test_whole_float_default::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_whole_float_default::Builder<'a, T>; +} +impl _p::ty::Struct for TestWholeFloatDefault { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; +} +impl TestWholeFloatDefault { + const FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 123f32, + }; + const BIG_FIELD: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: 2000000000000000000000000000000f32, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_whole_float_default::Reader<'p, T> { + #[inline] + pub fn field(&self) -> _p::Accessor<'_, 'p, T, f32> { + unsafe { + ::accessor( + &self.0, + &TestWholeFloatDefault::FIELD, + ) + } + } + #[inline] + pub fn big_field(&self) -> _p::Accessor<'_, 'p, T, f32> { + unsafe { + ::accessor( + &self.0, + &TestWholeFloatDefault::BIG_FIELD, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_whole_float_default::Builder<'p, T> { + #[inline] + pub fn field(&mut self) -> _p::AccessorMut<'_, 'p, T, f32> { + unsafe { + ::accessor( + &mut self.0, + &TestWholeFloatDefault::FIELD, + ) + } + } + #[inline] + pub fn big_field(&mut self) -> _p::AccessorMut<'_, 'p, T, f32> { + unsafe { + ::accessor( + &mut self.0, + &TestWholeFloatDefault::BIG_FIELD, + ) + } + } +} +pub mod test_whole_float_default { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestWholeFloatDefault< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestWholeFloatDefault< + _p::StructBuilder<'a, T>, + >; + pub const CONSTANT: f32 = 456f32; + pub const BIG_CONSTANT: f32 = 4000000000000000000000000000000f32; +} +#[derive(Clone)] +pub struct TestGenerics(T); +impl _p::IntoFamily for TestGenerics { + type Family = TestGenerics; +} +impl _p::Capable for TestGenerics { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestGenerics>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestGenerics(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_generics::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_generics::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestGenerics(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_generics::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_generics::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_generics::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_generics::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_generics::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_generics::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_generics::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_generics::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestGenerics { + type Reader<'a, T: _p::rpc::Table> = test_generics::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_generics::Builder<'a, T>; +} +impl _p::ty::Struct for TestGenerics { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 3u16, + }; +} +impl TestGenerics { + const FOO: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const REV: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; + const LIST: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 2u32, + default: ::core::option::Option::None, + }; + const UV: _p::VariantDescriptor<()> = _p::VariantDescriptor::<()> { + variant: _p::VariantInfo { + slot: 0u32, + case: 0u16, + }, + field: (), + }; + const UG: _p::VariantDescriptor<_p::Group> = _p::VariantDescriptor::< + _p::Group, + > { + variant: _p::VariantInfo { + slot: 0u32, + case: 1u16, + }, + field: (), + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_generics::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&self.0, &TestGenerics::FOO) + } + } + #[inline] + pub fn rev(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&self.0, &TestGenerics::REV) + } + } + #[inline] + pub fn list( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestGenerics::LIST) + } + } + #[inline] + pub fn uv(&self) -> _p::Variant<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::variant(&self.0, &TestGenerics::UV) } + } + #[inline] + pub fn ug(&self) -> _p::Variant<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_generics::Ug, + > as _p::field::FieldType>::variant(&self.0, &TestGenerics::UG) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_generics::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &TestGenerics::FOO, + ) + } + } + #[inline] + pub fn rev(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&mut self.0, &TestGenerics::REV) + } + } + #[inline] + pub fn list( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestGenerics::LIST) + } + } + #[inline] + pub fn uv(&mut self) -> _p::VariantMut<'_, 'p, T, ()> { + unsafe { <() as _p::field::FieldType>::variant(&mut self.0, &TestGenerics::UV) } + } + #[inline] + pub fn ug(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_generics::Ug, + > as _p::field::FieldType>::variant(&mut self.0, &TestGenerics::UG) + } + } + #[inline] + pub fn into_foo(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(self.0, &TestGenerics::FOO) + } + } + #[inline] + pub fn into_rev(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(self.0, &TestGenerics::REV) + } + } + #[inline] + pub fn into_list( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestGenerics::LIST) + } + } + #[inline] + pub fn into_ug(self) -> _p::VariantOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_generics::Ug, + > as _p::field::FieldType>::variant(self.0, &TestGenerics::UG) + } + } + #[inline] + pub fn which(&mut self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +pub mod test_generics { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestGenerics< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestGenerics< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Uv(_p::ViewOf), + Ug(_p::ViewOf>), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get(repr: &'b Reader<'p, T>) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::Uv( + <() as _p::field::FieldType>::accessor( + &repr.0, + &super::TestGenerics::UV.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Ug( + <_p::Group< + Ug, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::TestGenerics::UG.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::Uv( + <() as _p::field::FieldType>::accessor( + &mut repr.0, + &super::TestGenerics::UV.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Ug( + <_p::Group< + Ug, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::TestGenerics::UG.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + #[derive(Clone)] + pub struct Inner(T); + impl _p::IntoFamily for Inner { + type Family = Inner; + } + impl _p::Capable for Inner { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Inner>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Inner(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for inner::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for inner::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Inner(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: inner::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for inner::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for inner::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for inner::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: inner::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for inner::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for inner::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for inner::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Inner { + type Reader<'a, T: _p::rpc::Table> = inner::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = inner::Builder<'a, T>; + } + impl _p::ty::Struct for Inner { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 2u16, + }; + } + impl Inner { + const FOO: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const BAR: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 1u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> inner::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&self.0, &Inner::FOO) + } + } + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&self.0, &Inner::BAR) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> inner::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&mut self.0, &Inner::FOO) + } + } + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&mut self.0, &Inner::BAR) + } + } + #[inline] + pub fn into_foo(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(self.0, &Inner::FOO) + } + } + #[inline] + pub fn into_bar(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(self.0, &Inner::BAR) + } + } + } + pub mod inner { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Inner<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Inner< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Inner2(T); + impl _p::IntoFamily for Inner2 { + type Family = Inner2; + } + impl _p::Capable for Inner2 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Inner2>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Inner2(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for inner2::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for inner2::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Inner2(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: inner2::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for inner2::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for inner2::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for inner2::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: inner2::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for inner2::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for inner2::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for inner2::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Inner2 { + type Reader<'a, T: _p::rpc::Table> = inner2::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = inner2::Builder<'a, T>; + } + impl _p::ty::Struct for Inner2 { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 4u16, + }; + } + impl Inner2 { + const BAR: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const BAZ: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 1u32, + default: ::core::option::Option::None, + }; + const INNER_BOUND: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 2u32, + default: ::core::option::Option::None, + }; + const INNER_UNBOUND: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 3u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> inner2::Reader<'p, T> { + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&self.0, &Inner2::BAR) + } + } + #[inline] + pub fn baz(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&self.0, &Inner2::BAZ) + } + } + #[inline] + pub fn inner_bound(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner, + > as _p::field::FieldType>::accessor(&self.0, &Inner2::INNER_BOUND) + } + } + #[inline] + pub fn inner_unbound(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner, + > as _p::field::FieldType>::accessor(&self.0, &Inner2::INNER_UNBOUND) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> inner2::Builder<'p, T> { + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&mut self.0, &Inner2::BAR) + } + } + #[inline] + pub fn baz(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&mut self.0, &Inner2::BAZ) + } + } + #[inline] + pub fn inner_bound(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner, + > as _p::field::FieldType>::accessor(&mut self.0, &Inner2::INNER_BOUND) + } + } + #[inline] + pub fn inner_unbound( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner, + > as _p::field::FieldType>::accessor(&mut self.0, &Inner2::INNER_UNBOUND) + } + } + #[inline] + pub fn into_bar(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(self.0, &Inner2::BAR) + } + } + #[inline] + pub fn into_baz(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(self.0, &Inner2::BAZ) + } + } + #[inline] + pub fn into_inner_bound(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner, + > as _p::field::FieldType>::accessor(self.0, &Inner2::INNER_BOUND) + } + } + #[inline] + pub fn into_inner_unbound(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner, + > as _p::field::FieldType>::accessor(self.0, &Inner2::INNER_UNBOUND) + } + } + } + pub mod inner2 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Inner2<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Inner2< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct DeepNest(T); + impl _p::IntoFamily for DeepNest { + type Family = DeepNest; + } + impl _p::Capable for DeepNest { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = DeepNest>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (DeepNest(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for deep_nest::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for deep_nest::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + DeepNest(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: deep_nest::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for deep_nest::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for deep_nest::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for deep_nest::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: deep_nest::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for deep_nest::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for deep_nest::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for deep_nest::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for DeepNest { + type Reader<'a, T: _p::rpc::Table> = deep_nest::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = deep_nest::Builder<'a, T>; + } + impl _p::ty::Struct for DeepNest { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 4u16, + }; + } + impl DeepNest { + const FOO: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const BAR: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 1u32, + default: ::core::option::Option::None, + }; + const BAZ: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 2u32, + default: ::core::option::Option::None, + }; + const QUX: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 3u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> deep_nest::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &DeepNest::FOO, + ) + } + } + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &DeepNest::BAR, + ) + } + } + #[inline] + pub fn baz(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &DeepNest::BAZ, + ) + } + } + #[inline] + pub fn qux(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &DeepNest::QUX, + ) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> deep_nest::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &DeepNest::FOO, + ) + } + } + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &DeepNest::BAR, + ) + } + } + #[inline] + pub fn baz(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &DeepNest::BAZ, + ) + } + } + #[inline] + pub fn qux(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &DeepNest::QUX, + ) + } + } + #[inline] + pub fn into_foo(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &DeepNest::FOO, + ) + } + } + #[inline] + pub fn into_bar(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &DeepNest::BAR, + ) + } + } + #[inline] + pub fn into_baz(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &DeepNest::BAZ, + ) + } + } + #[inline] + pub fn into_qux(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &DeepNest::QUX, + ) + } + } + } + pub mod deep_nest { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::DeepNest< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::DeepNest< + _p::StructBuilder<'a, T>, + >; + } + } + #[derive(Clone)] + pub struct UseAliases(T); + impl _p::IntoFamily for UseAliases { + type Family = UseAliases; + } + impl _p::Capable for UseAliases { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = UseAliases>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (UseAliases(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for use_aliases::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for use_aliases::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + UseAliases(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: use_aliases::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for use_aliases::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for use_aliases::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for use_aliases::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: use_aliases::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for use_aliases::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for use_aliases::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for use_aliases::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for UseAliases { + type Reader<'a, T: _p::rpc::Table> = use_aliases::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = use_aliases::Builder<'a, T>; + } + impl _p::ty::Struct for UseAliases { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 6u16, + }; + } + impl UseAliases { + const FOO: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const INNER: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; + const INNER2: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 2u32, + default: ::core::option::Option::None, + }; + const INNER2_BIND: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 3u32, + default: ::core::option::Option::None, + }; + const INNER2_TEXT: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 4u32, + default: ::core::option::Option::None, + }; + const REV_FOO: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 5u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> use_aliases::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&self.0, &UseAliases::FOO) + } + } + #[inline] + pub fn inner(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner, + > as _p::field::FieldType>::accessor(&self.0, &UseAliases::INNER) + } + } + #[inline] + pub fn inner2(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner2, + > as _p::field::FieldType>::accessor(&self.0, &UseAliases::INNER2) + } + } + #[inline] + pub fn inner2_bind(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner2, + > as _p::field::FieldType>::accessor(&self.0, &UseAliases::INNER2_BIND) + } + } + #[inline] + pub fn inner2_text(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner2, + > as _p::field::FieldType>::accessor(&self.0, &UseAliases::INNER2_TEXT) + } + } + #[inline] + pub fn rev_foo(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &UseAliases::REV_FOO, + ) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> use_aliases::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &UseAliases::FOO, + ) + } + } + #[inline] + pub fn inner(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner, + > as _p::field::FieldType>::accessor(&mut self.0, &UseAliases::INNER) + } + } + #[inline] + pub fn inner2(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner2, + > as _p::field::FieldType>::accessor(&mut self.0, &UseAliases::INNER2) + } + } + #[inline] + pub fn inner2_bind(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner2, + > as _p::field::FieldType>::accessor( + &mut self.0, + &UseAliases::INNER2_BIND, + ) + } + } + #[inline] + pub fn inner2_text(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner2, + > as _p::field::FieldType>::accessor( + &mut self.0, + &UseAliases::INNER2_TEXT, + ) + } + } + #[inline] + pub fn rev_foo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &UseAliases::REV_FOO, + ) + } + } + #[inline] + pub fn into_foo(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(self.0, &UseAliases::FOO) + } + } + #[inline] + pub fn into_inner(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner, + > as _p::field::FieldType>::accessor(self.0, &UseAliases::INNER) + } + } + #[inline] + pub fn into_inner2(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner2, + > as _p::field::FieldType>::accessor(self.0, &UseAliases::INNER2) + } + } + #[inline] + pub fn into_inner2_bind(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner2, + > as _p::field::FieldType>::accessor(self.0, &UseAliases::INNER2_BIND) + } + } + #[inline] + pub fn into_inner2_text(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + Inner2, + > as _p::field::FieldType>::accessor(self.0, &UseAliases::INNER2_TEXT) + } + } + #[inline] + pub fn into_rev_foo(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &UseAliases::REV_FOO, + ) + } + } + } + pub mod use_aliases { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::UseAliases< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::UseAliases< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct Ug(T); + impl _p::IntoFamily for Ug { + type Family = Ug; + } + impl _p::Capable for Ug { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Ug>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Ug(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for ug::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for ug::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Ug(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: ug::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for ug::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for ug::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for ug::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: ug::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for ug::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for ug::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for ug::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Ug { + type Reader<'a, T: _p::rpc::Table> = ug::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = ug::Builder<'a, T>; + } + impl _p::FieldGroup for Ug { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + ::clear(s, &Ug::UGFOO); + } + } + impl Ug { + const UGFOO: _p::Descriptor = _p::Descriptor:: { + slot: 1u32, + default: 0i32, + }; + } + impl<'p, T: _p::rpc::Table + 'p> ug::Reader<'p, T> { + #[inline] + pub fn ugfoo(&self) -> _p::Accessor<'_, 'p, T, i32> { + unsafe { ::accessor(&self.0, &Ug::UGFOO) } + } + } + impl<'p, T: _p::rpc::Table + 'p> ug::Builder<'p, T> { + #[inline] + pub fn ugfoo(&mut self) -> _p::AccessorMut<'_, 'p, T, i32> { + unsafe { ::accessor(&mut self.0, &Ug::UGFOO) } + } + } + pub mod ug { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Ug<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::Ug<_p::StructBuilder<'a, T>>; + } +} +#[derive(Clone)] +pub struct BoxedText(T); +impl _p::IntoFamily for BoxedText { + type Family = BoxedText; +} +impl _p::Capable for BoxedText { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = BoxedText>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (BoxedText(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for boxed_text::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for boxed_text::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + BoxedText(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: boxed_text::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for boxed_text::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for boxed_text::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for boxed_text::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: boxed_text::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for boxed_text::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for boxed_text::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for boxed_text::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for BoxedText { + type Reader<'a, T: _p::rpc::Table> = boxed_text::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = boxed_text::Builder<'a, T>; +} +impl _p::ty::Struct for BoxedText { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; +} +impl BoxedText { + const TEXT: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> boxed_text::Reader<'p, T> { + #[inline] + pub fn text(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &BoxedText::TEXT) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> boxed_text::Builder<'p, T> { + #[inline] + pub fn text(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &BoxedText::TEXT) + } + } + #[inline] + pub fn into_text(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { <_p::Text as _p::field::FieldType>::accessor(self.0, &BoxedText::TEXT) } + } +} +pub mod boxed_text { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::BoxedText<_p::StructReader<'a, T>>; + pub type Builder<'a, T = _p::rpc::Empty> = super::BoxedText< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestGenericsWrapper(T); +impl _p::IntoFamily for TestGenericsWrapper { + type Family = TestGenericsWrapper; +} +impl _p::Capable for TestGenericsWrapper { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestGenericsWrapper>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestGenericsWrapper(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_generics_wrapper::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_generics_wrapper::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestGenericsWrapper(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_generics_wrapper::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_generics_wrapper::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_generics_wrapper::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_generics_wrapper::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_generics_wrapper::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_generics_wrapper::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_generics_wrapper::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_generics_wrapper::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestGenericsWrapper { + type Reader<'a, T: _p::rpc::Table> = test_generics_wrapper::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_generics_wrapper::Builder<'a, T>; +} +impl _p::ty::Struct for TestGenericsWrapper { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; +} +impl TestGenericsWrapper { + const VALUE: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_generics_wrapper::Reader<'p, T> { + #[inline] + pub fn value(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&self.0, &TestGenericsWrapper::VALUE) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_generics_wrapper::Builder<'p, T> { + #[inline] + pub fn value(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestGenericsWrapper::VALUE, + ) + } + } + #[inline] + pub fn into_value(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(self.0, &TestGenericsWrapper::VALUE) + } + } +} +pub mod test_generics_wrapper { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestGenericsWrapper< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestGenericsWrapper< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestGenericsWrapper2(T); +impl _p::IntoFamily for TestGenericsWrapper2 { + type Family = TestGenericsWrapper2; +} +impl _p::Capable for TestGenericsWrapper2 { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestGenericsWrapper2>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestGenericsWrapper2(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_generics_wrapper2::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_generics_wrapper2::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestGenericsWrapper2(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_generics_wrapper2::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_generics_wrapper2::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_generics_wrapper2::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_generics_wrapper2::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_generics_wrapper2::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_generics_wrapper2::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_generics_wrapper2::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_generics_wrapper2::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestGenericsWrapper2 { + type Reader<'a, T: _p::rpc::Table> = test_generics_wrapper2::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_generics_wrapper2::Builder<'a, T>; +} +impl _p::ty::Struct for TestGenericsWrapper2 { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; +} +impl TestGenericsWrapper2 { + const VALUE: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_generics_wrapper2::Reader<'p, T> { + #[inline] + pub fn value(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper, + > as _p::field::FieldType>::accessor(&self.0, &TestGenericsWrapper2::VALUE) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_generics_wrapper2::Builder<'p, T> { + #[inline] + pub fn value( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestGenericsWrapper2::VALUE, + ) + } + } + #[inline] + pub fn into_value( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper, + > as _p::field::FieldType>::accessor(self.0, &TestGenericsWrapper2::VALUE) + } + } +} +pub mod test_generics_wrapper2 { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestGenericsWrapper2< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestGenericsWrapper2< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestGenericsUnion(T); +impl _p::IntoFamily for TestGenericsUnion { + type Family = TestGenericsUnion; +} +impl _p::Capable for TestGenericsUnion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestGenericsUnion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestGenericsUnion(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_generics_union::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_generics_union::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestGenericsUnion(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_generics_union::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_generics_union::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_generics_union::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_generics_union::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_generics_union::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_generics_union::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_generics_union::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_generics_union::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestGenericsUnion { + type Reader<'a, T: _p::rpc::Table> = test_generics_union::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_generics_union::Builder<'a, T>; +} +impl _p::ty::Struct for TestGenericsUnion { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; +} +impl TestGenericsUnion { + const FOO: _p::VariantDescriptor<_p::AnyPtr> = _p::VariantDescriptor::<_p::AnyPtr> { + variant: _p::VariantInfo { + slot: 0u32, + case: 0u16, + }, + field: _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }, + }; + const BAR: _p::VariantDescriptor<_p::AnyPtr> = _p::VariantDescriptor::<_p::AnyPtr> { + variant: _p::VariantInfo { + slot: 0u32, + case: 1u16, + }, + field: _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_generics_union::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Variant<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::variant( + &self.0, + &TestGenericsUnion::FOO, + ) + } + } + #[inline] + pub fn bar(&self) -> _p::Variant<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::variant( + &self.0, + &TestGenericsUnion::BAR, + ) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_generics_union::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::VariantMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::variant( + &mut self.0, + &TestGenericsUnion::FOO, + ) + } + } + #[inline] + pub fn bar(&mut self) -> _p::VariantMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::variant( + &mut self.0, + &TestGenericsUnion::BAR, + ) + } + } + #[inline] + pub fn into_foo(self) -> _p::VariantOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::variant( + self.0, + &TestGenericsUnion::FOO, + ) + } + } + #[inline] + pub fn into_bar(self) -> _p::VariantOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::variant( + self.0, + &TestGenericsUnion::BAR, + ) + } + } + #[inline] + pub fn which( + &mut self, + ) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +pub mod test_generics_union { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestGenericsUnion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestGenericsUnion< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + Foo(_p::ViewOf), + Bar(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get(repr: &'b Reader<'p, T>) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::Foo( + <_p::AnyPtr as _p::field::FieldType>::accessor( + &repr.0, + &super::TestGenericsUnion::FOO.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Bar( + <_p::AnyPtr as _p::field::FieldType>::accessor( + &repr.0, + &super::TestGenericsUnion::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(0usize); + match tag { + 0u16 => { + Ok( + Which::Foo( + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut repr.0, + &super::TestGenericsUnion::FOO.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Bar( + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut repr.0, + &super::TestGenericsUnion::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } +} +#[derive(Clone)] +pub struct TestUseGenerics(T); +impl _p::IntoFamily for TestUseGenerics { + type Family = TestUseGenerics; +} +impl _p::Capable for TestUseGenerics { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestUseGenerics>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestUseGenerics(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_use_generics::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_use_generics::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestUseGenerics(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_use_generics::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_use_generics::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_use_generics::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_use_generics::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_use_generics::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_use_generics::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_use_generics::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_use_generics::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestUseGenerics { + type Reader<'a, T: _p::rpc::Table> = test_use_generics::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_use_generics::Builder<'a, T>; +} +impl _p::ty::Struct for TestUseGenerics { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 20u16, + }; +} +impl TestUseGenerics { + const BASIC: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; + const INNER: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; + const INNER2: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 2u32, + default: ::core::option::Option::None, + }; + const UNSPECIFIED: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 3u32, + default: ::core::option::Option::None, + }; + const UNSPECIFIED_INNER: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 4u32, + default: ::core::option::Option::None, + }; + const DEFAULT: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 5u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([108u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 65u8, 1u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 1u16, + ptrs: 3u16, + }, + ) + }), + }; + const DEFAULT_INNER: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 6u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([105u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 2u16, + }, + ) + }), + }; + const DEFAULT_USER: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 7u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([76u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 20u16, + }, + ) + }), + }; + const WRAPPER: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 8u32, + default: ::core::option::Option::None, + }; + const DEFAULT_WRAPPER: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 9u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 65u8, 1u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 1u16, + }, + ) + }), + }; + const DEFAULT_WRAPPER2: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 10u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 65u8, 1u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 1u16, + }, + ) + }), + }; + const ALIAS_FOO: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 11u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 6u16, + ptrs: 20u16, + }, + ) + }), + }; + const ALIAS_INNER: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 12u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 2u16, + }, + ) + }), + }; + const ALIAS_INNER2: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 13u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 4u16, + }, + ) + }), + }; + const ALIAS_INNER2_BIND: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 14u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 20u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 4u16, + }, + ) + }), + }; + const ALIAS_INNER2_TEXT: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 15u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 4u16, + }, + ) + }), + }; + const ALIAS_REV: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 16u32, + default: ::core::option::Option::Some(_p::text::Reader::from_slice(b"text\0")), + }; + const USE_ALIASES: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 17u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([20u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([120u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8]), + _p::Word([228u8, 0u8, 0u8, 0u8, 0u8, 0u8, 4u8, 0u8]), + _p::Word([96u8, 1u8, 0u8, 0u8, 0u8, 0u8, 4u8, 0u8]), + _p::Word([224u8, 1u8, 0u8, 0u8, 0u8, 0u8, 4u8, 0u8]), + _p::Word([97u8, 2u8, 0u8, 0u8, 28u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([4u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([56u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 0u16, + ptrs: 6u16, + }, + ) + }), + }; + const CAP: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 18u32, + default: ::core::option::Option::None, + }; + const GENERIC_CAP: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 19u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_use_generics::Reader<'p, T> { + #[inline] + pub fn basic(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::BASIC) + } + } + #[inline] + pub fn inner(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::INNER) + } + } + #[inline] + pub fn inner2(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::INNER2) + } + } + #[inline] + pub fn unspecified(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::UNSPECIFIED) + } + } + #[inline] + pub fn unspecified_inner( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + &self.0, + &TestUseGenerics::UNSPECIFIED_INNER, + ) + } + } + #[inline] + pub fn default(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::DEFAULT) + } + } + #[inline] + pub fn default_inner( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner, + > as _p::field::FieldType>::accessor( + &self.0, + &TestUseGenerics::DEFAULT_INNER, + ) + } + } + #[inline] + pub fn default_user(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUseGenerics, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::DEFAULT_USER) + } + } + #[inline] + pub fn wrapper(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::WRAPPER) + } + } + #[inline] + pub fn default_wrapper( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper, + > as _p::field::FieldType>::accessor( + &self.0, + &TestUseGenerics::DEFAULT_WRAPPER, + ) + } + } + #[inline] + pub fn default_wrapper2( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper2, + > as _p::field::FieldType>::accessor( + &self.0, + &TestUseGenerics::DEFAULT_WRAPPER2, + ) + } + } + #[inline] + pub fn alias_foo(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestAllTypes, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::ALIAS_FOO) + } + } + #[inline] + pub fn alias_inner( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::ALIAS_INNER) + } + } + #[inline] + pub fn alias_inner2( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::ALIAS_INNER2) + } + } + #[inline] + pub fn alias_inner2_bind( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + &self.0, + &TestUseGenerics::ALIAS_INNER2_BIND, + ) + } + } + #[inline] + pub fn alias_inner2_text( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + &self.0, + &TestUseGenerics::ALIAS_INNER2_TEXT, + ) + } + } + #[inline] + pub fn alias_rev(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &TestUseGenerics::ALIAS_REV, + ) + } + } + #[inline] + pub fn use_aliases( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::UseAliases, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::USE_ALIASES) + } + } + #[inline] + pub fn cap(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&self.0, &TestUseGenerics::CAP) + } + } + #[inline] + pub fn generic_cap(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &TestUseGenerics::GENERIC_CAP, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_use_generics::Builder<'p, T> { + #[inline] + pub fn basic(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUseGenerics::BASIC) + } + } + #[inline] + pub fn inner( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUseGenerics::INNER) + } + } + #[inline] + pub fn inner2( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUseGenerics::INNER2) + } + } + #[inline] + pub fn unspecified( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::UNSPECIFIED, + ) + } + } + #[inline] + pub fn unspecified_inner( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::UNSPECIFIED_INNER, + ) + } + } + #[inline] + pub fn default(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUseGenerics::DEFAULT) + } + } + #[inline] + pub fn default_inner( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::DEFAULT_INNER, + ) + } + } + #[inline] + pub fn default_user( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUseGenerics, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::DEFAULT_USER, + ) + } + } + #[inline] + pub fn wrapper( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUseGenerics::WRAPPER) + } + } + #[inline] + pub fn default_wrapper( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::DEFAULT_WRAPPER, + ) + } + } + #[inline] + pub fn default_wrapper2( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper2, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::DEFAULT_WRAPPER2, + ) + } + } + #[inline] + pub fn alias_foo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestAllTypes, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::ALIAS_FOO, + ) + } + } + #[inline] + pub fn alias_inner( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::ALIAS_INNER, + ) + } + } + #[inline] + pub fn alias_inner2( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::ALIAS_INNER2, + ) + } + } + #[inline] + pub fn alias_inner2_bind( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::ALIAS_INNER2_BIND, + ) + } + } + #[inline] + pub fn alias_inner2_text( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::ALIAS_INNER2_TEXT, + ) + } + } + #[inline] + pub fn alias_rev(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::ALIAS_REV, + ) + } + } + #[inline] + pub fn use_aliases( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::UseAliases, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::USE_ALIASES, + ) + } + } + #[inline] + pub fn cap(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(&mut self.0, &TestUseGenerics::CAP) + } + } + #[inline] + pub fn generic_cap(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &TestUseGenerics::GENERIC_CAP, + ) + } + } + #[inline] + pub fn into_basic(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::BASIC) + } + } + #[inline] + pub fn into_inner( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::INNER) + } + } + #[inline] + pub fn into_inner2( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::INNER2) + } + } + #[inline] + pub fn into_unspecified(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::UNSPECIFIED) + } + } + #[inline] + pub fn into_unspecified_inner( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + self.0, + &TestUseGenerics::UNSPECIFIED_INNER, + ) + } + } + #[inline] + pub fn into_default(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::DEFAULT) + } + } + #[inline] + pub fn into_default_inner( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::DEFAULT_INNER) + } + } + #[inline] + pub fn into_default_user( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestUseGenerics, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::DEFAULT_USER) + } + } + #[inline] + pub fn into_wrapper( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::WRAPPER) + } + } + #[inline] + pub fn into_default_wrapper( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper, + > as _p::field::FieldType>::accessor( + self.0, + &TestUseGenerics::DEFAULT_WRAPPER, + ) + } + } + #[inline] + pub fn into_default_wrapper2( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenericsWrapper2, + > as _p::field::FieldType>::accessor( + self.0, + &TestUseGenerics::DEFAULT_WRAPPER2, + ) + } + } + #[inline] + pub fn into_alias_foo(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestAllTypes, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::ALIAS_FOO) + } + } + #[inline] + pub fn into_alias_inner( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::ALIAS_INNER) + } + } + #[inline] + pub fn into_alias_inner2( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::ALIAS_INNER2) + } + } + #[inline] + pub fn into_alias_inner2_bind( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + self.0, + &TestUseGenerics::ALIAS_INNER2_BIND, + ) + } + } + #[inline] + pub fn into_alias_inner2_text( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::Inner2, + > as _p::field::FieldType>::accessor( + self.0, + &TestUseGenerics::ALIAS_INNER2_TEXT, + ) + } + } + #[inline] + pub fn into_alias_rev(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + self.0, + &TestUseGenerics::ALIAS_REV, + ) + } + } + #[inline] + pub fn into_use_aliases( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_generics::UseAliases, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::USE_ALIASES) + } + } + #[inline] + pub fn into_cap(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestGenerics, + > as _p::field::FieldType>::accessor(self.0, &TestUseGenerics::CAP) + } + } + #[inline] + pub fn into_generic_cap(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &TestUseGenerics::GENERIC_CAP, + ) + } + } +} +pub mod test_use_generics { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestUseGenerics< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestUseGenerics< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestEmptyStruct(T); +impl _p::IntoFamily for TestEmptyStruct { + type Family = TestEmptyStruct; +} +impl _p::Capable for TestEmptyStruct { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestEmptyStruct>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestEmptyStruct(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_empty_struct::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_empty_struct::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestEmptyStruct(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_empty_struct::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_empty_struct::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_empty_struct::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_empty_struct::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_empty_struct::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_empty_struct::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_empty_struct::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_empty_struct::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestEmptyStruct { + type Reader<'a, T: _p::rpc::Table> = test_empty_struct::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_empty_struct::Builder<'a, T>; +} +impl _p::ty::Struct for TestEmptyStruct { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 0u16, + }; +} +impl TestEmptyStruct {} +impl<'p, T: _p::rpc::Table + 'p> test_empty_struct::Reader<'p, T> {} +impl<'p, T: _p::rpc::Table + 'p> test_empty_struct::Builder<'p, T> {} +pub mod test_empty_struct { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestEmptyStruct< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestEmptyStruct< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestConstants(T); +impl _p::IntoFamily for TestConstants { + type Family = TestConstants; +} +impl _p::Capable for TestConstants { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestConstants>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestConstants(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_constants::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_constants::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestConstants(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_constants::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_constants::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_constants::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_constants::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_constants::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_constants::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_constants::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_constants::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestConstants { + type Reader<'a, T: _p::rpc::Table> = test_constants::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_constants::Builder<'a, T>; +} +impl _p::ty::Struct for TestConstants { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 0u16, + }; +} +impl TestConstants {} +impl<'p, T: _p::rpc::Table + 'p> test_constants::Reader<'p, T> {} +impl<'p, T: _p::rpc::Table + 'p> test_constants::Builder<'p, T> {} +pub mod test_constants { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestConstants< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestConstants< + _p::StructBuilder<'a, T>, + >; + pub const VOID_CONST: () = (); + pub const BOOL_CONST: bool = true; + pub const INT8_CONST: i8 = -123i8; + pub const INT16_CONST: i16 = -12345i16; + pub const INT32_CONST: i32 = -12345678i32; + pub const INT64_CONST: i64 = -123456789012345i64; + pub const UINT8_CONST: u8 = 234u8; + pub const UINT16_CONST: u16 = 45678u16; + pub const UINT32_CONST: u32 = 3456789012u32; + pub const UINT64_CONST: u64 = 12345678901234567890u64; + pub const FLOAT32_CONST: f32 = 1234.5f32; + pub const FLOAT64_CONST: f64 = -123000000000000000000000000000000000000000000000f64; + pub const TEXT_CONST: _p::ty::ConstPtr<_p::Text> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const DATA_CONST: _p::ty::ConstPtr<_p::Data> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 26u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 114u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const STRUCT_CONST: _p::ty::ConstPtr<_p::Struct> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([1u8, 244u8, 128u8, 13u8, 14u8, 16u8, 76u8, 251u8]), + _p::Word([78u8, 115u8, 232u8, 56u8, 166u8, 51u8, 0u8, 0u8]), + _p::Word([90u8, 0u8, 210u8, 4u8, 20u8, 136u8, 98u8, 3u8]), + _p::Word([210u8, 10u8, 111u8, 18u8, 33u8, 25u8, 204u8, 4u8]), + _p::Word([95u8, 112u8, 9u8, 175u8, 2u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 144u8, 117u8, 64u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 26u8, 0u8, 0u8, 0u8]), + _p::Word([76u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 24u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 41u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([37u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([53u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([65u8, 1u8, 0u8, 0u8, 52u8, 0u8, 0u8, 0u8]), + _p::Word([73u8, 1u8, 0u8, 0u8, 53u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 1u8, 0u8, 0u8, 119u8, 2u8, 0u8, 0u8]), + _p::Word([213u8, 2u8, 0u8, 0u8, 27u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 122u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([72u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([110u8, 101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 114u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([114u8, 101u8, 97u8, 108u8, 108u8, 121u8, 32u8, 110u8]), + _p::Word([101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8, 0u8]), + _p::Word([26u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 222u8, 128u8, 127u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 210u8, 233u8, 0u8, 128u8, 255u8, 127u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 64u8, 211u8, 160u8, 250u8]), + _p::Word([0u8, 0u8, 0u8, 128u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([46u8, 117u8, 19u8, 253u8, 138u8, 150u8, 253u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 128u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([12u8, 34u8, 0u8, 255u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 46u8, 22u8, 0u8, 0u8, 255u8, 255u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 192u8, 44u8, 95u8, 5u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([210u8, 138u8, 236u8, 2u8, 117u8, 105u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 56u8, 180u8, 150u8, 73u8]), + _p::Word([194u8, 189u8, 240u8, 124u8, 194u8, 189u8, 240u8, 252u8]), + _p::Word([234u8, 28u8, 8u8, 2u8, 234u8, 28u8, 8u8, 130u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([64u8, 222u8, 119u8, 131u8, 33u8, 18u8, 220u8, 66u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 127u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 255u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 0u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 128u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([99u8, 111u8, 114u8, 103u8, 101u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 114u8, 97u8, 117u8, 108u8, 116u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 97u8, 114u8, 112u8, 108u8, 121u8, 0u8, 0u8]), + _p::Word([119u8, 97u8, 108u8, 100u8, 111u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 114u8, 101u8, 100u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 49u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 50u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 51u8, 0u8, 0u8]), + _p::Word([3u8, 0u8, 1u8, 0u8, 6u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const ENUM_CONST: super::TestEnum = super::TestEnum::Corge; + pub const VOID_LIST_CONST: _p::ty::ConstPtr<_p::List<()>> = unsafe { + _p::ty::ConstPtr::new(&[_p::Word([1u8, 0u8, 0u8, 0u8, 48u8, 0u8, 0u8, 0u8])]) + }; + pub const BOOL_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 33u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const INT8_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 18u8, 0u8, 0u8, 0u8]), + _p::Word([111u8, 145u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const INT16_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 19u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 43u8, 153u8, 212u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const INT32_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 20u8, 0u8, 0u8, 0u8]), + _p::Word([199u8, 107u8, 159u8, 6u8, 57u8, 148u8, 96u8, 249u8]), + ], + ) + }; + pub const INT64_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 21u8, 0u8, 0u8, 0u8]), + _p::Word([199u8, 113u8, 196u8, 43u8, 171u8, 117u8, 107u8, 15u8]), + _p::Word([57u8, 142u8, 59u8, 212u8, 84u8, 138u8, 148u8, 240u8]), + ], + ) + }; + pub const UINT8_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 18u8, 0u8, 0u8, 0u8]), + _p::Word([111u8, 222u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const UINT16_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 19u8, 0u8, 0u8, 0u8]), + _p::Word([53u8, 130u8, 156u8, 173u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const UINT32_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 12u8, 0u8, 0u8, 0u8]), + _p::Word([85u8, 161u8, 174u8, 198u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const UINT64_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 13u8, 0u8, 0u8, 0u8]), + _p::Word([199u8, 113u8, 172u8, 181u8, 175u8, 152u8, 50u8, 154u8]), + ], + ) + }; + pub const FLOAT32_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 156u8, 173u8, 69u8, 0u8, 0u8, 128u8, 127u8]), + _p::Word([0u8, 0u8, 128u8, 255u8, 0u8, 0u8, 192u8, 127u8]), + ], + ) + }; + pub const FLOAT64_LIST_CONST: _p::ty::ConstPtr<_p::List> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 192u8, 97u8, 190u8, 64u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 240u8, 127u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 240u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 248u8, 127u8]), + ], + ) + }; + pub const TEXT_LIST_CONST: _p::ty::ConstPtr<_p::List<_p::Text>> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([112u8, 108u8, 117u8, 103u8, 104u8, 0u8, 0u8, 0u8]), + _p::Word([120u8, 121u8, 122u8, 122u8, 121u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 104u8, 117u8, 100u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const DATA_LIST_CONST: _p::ty::ConstPtr<_p::List<_p::Data>> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 74u8, 0u8, 0u8, 0u8]), + _p::Word([13u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([111u8, 111u8, 112u8, 115u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([101u8, 120u8, 104u8, 97u8, 117u8, 115u8, 116u8, 101u8]), + _p::Word([100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([114u8, 102u8, 99u8, 51u8, 48u8, 57u8, 50u8, 0u8]), + ], + ) + }; + pub const STRUCT_LIST_CONST: _p::ty::ConstPtr< + _p::List<_p::Struct>, + > = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 119u8, 2u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 49u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 50u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 51u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; + pub const ENUM_LIST_CONST: _p::ty::ConstPtr<_p::List<_p::Enum>> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 19u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 7u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) + }; +} +pub const GLOBAL_INT: u32 = 12345u32; +pub const GLOBAL_TEXT: _p::ty::ConstPtr<_p::Text> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 98u8, 97u8, 114u8, 0u8, 0u8]), + ], + ) +}; +pub const GLOBAL_STRUCT: _p::ty::ConstPtr<_p::Struct> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 49u8, 212u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) +}; +pub const GLOBAL_PRINTABLE_STRUCT: _p::ty::ConstPtr< + _p::Struct, +> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) +}; +pub const DERIVED_CONSTANT: _p::ty::ConstPtr<_p::Struct> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 57u8, 48u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([72u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([117u8, 3u8, 0u8, 0u8, 19u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 3u8, 0u8, 0u8, 119u8, 2u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 244u8, 128u8, 13u8, 14u8, 16u8, 76u8, 251u8]), + _p::Word([78u8, 115u8, 232u8, 56u8, 166u8, 51u8, 0u8, 0u8]), + _p::Word([90u8, 0u8, 210u8, 4u8, 20u8, 136u8, 98u8, 3u8]), + _p::Word([210u8, 10u8, 111u8, 18u8, 33u8, 25u8, 204u8, 4u8]), + _p::Word([95u8, 112u8, 9u8, 175u8, 2u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 144u8, 117u8, 64u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 26u8, 0u8, 0u8, 0u8]), + _p::Word([76u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 24u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 41u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([37u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([53u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([65u8, 1u8, 0u8, 0u8, 52u8, 0u8, 0u8, 0u8]), + _p::Word([73u8, 1u8, 0u8, 0u8, 53u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 1u8, 0u8, 0u8, 119u8, 2u8, 0u8, 0u8]), + _p::Word([213u8, 2u8, 0u8, 0u8, 27u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 122u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([72u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([110u8, 101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 114u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([114u8, 101u8, 97u8, 108u8, 108u8, 121u8, 32u8, 110u8]), + _p::Word([101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8, 0u8]), + _p::Word([26u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 222u8, 128u8, 127u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 210u8, 233u8, 0u8, 128u8, 255u8, 127u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 64u8, 211u8, 160u8, 250u8]), + _p::Word([0u8, 0u8, 0u8, 128u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([46u8, 117u8, 19u8, 253u8, 138u8, 150u8, 253u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 128u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([12u8, 34u8, 0u8, 255u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 46u8, 22u8, 0u8, 0u8, 255u8, 255u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 192u8, 44u8, 95u8, 5u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([210u8, 138u8, 236u8, 2u8, 117u8, 105u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 56u8, 180u8, 150u8, 73u8]), + _p::Word([194u8, 189u8, 240u8, 124u8, 194u8, 189u8, 240u8, 252u8]), + _p::Word([234u8, 28u8, 8u8, 2u8, 234u8, 28u8, 8u8, 130u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([64u8, 222u8, 119u8, 131u8, 33u8, 18u8, 220u8, 66u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 127u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 255u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 0u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 128u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([99u8, 111u8, 114u8, 103u8, 101u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 114u8, 97u8, 117u8, 108u8, 116u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 97u8, 114u8, 112u8, 108u8, 121u8, 0u8, 0u8]), + _p::Word([119u8, 97u8, 108u8, 100u8, 111u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 114u8, 101u8, 100u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 49u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 50u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 51u8, 0u8, 0u8]), + _p::Word([3u8, 0u8, 1u8, 0u8, 6u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 43u8, 153u8, 212u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 49u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 50u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 51u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) +}; +pub const GENERIC_CONSTANT: _p::ty::ConstPtr<_p::Struct> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([108u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 123u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 65u8, 1u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) +}; +pub const EMBEDDED_DATA: _p::ty::ConstPtr<_p::Data> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 250u8, 25u8, 0u8, 0u8]), + _p::Word([48u8, 95u8, 1u8, 80u8, 6u8, 20u8, 255u8, 1u8]), + _p::Word([133u8, 199u8, 207u8, 178u8, 158u8, 67u8, 255u8, 3u8]), + _p::Word([135u8, 32u8, 242u8, 121u8, 183u8, 143u8, 255u8, 255u8]), + _p::Word([234u8, 0u8, 110u8, 178u8, 20u8, 106u8, 10u8, 206u8]), + _p::Word([210u8, 10u8, 31u8, 235u8, 140u8, 169u8, 84u8, 171u8]), + _p::Word([30u8, 80u8, 154u8, 68u8, 5u8, 254u8, 187u8, 224u8]), + _p::Word([192u8, 130u8, 139u8, 181u8, 201u8, 17u8, 77u8, 34u8]), + _p::Word([17u8, 77u8, 26u8, 81u8, 76u8, 6u8, 20u8, 19u8]), + _p::Word([133u8, 3u8, 48u8, 19u8, 129u8, 3u8, 33u8, 19u8]), + _p::Word([129u8, 3u8, 18u8, 19u8, 129u8, 3u8, 19u8, 19u8]), + _p::Word([129u8, 3u8, 20u8, 19u8, 129u8, 3u8, 21u8, 19u8]), + _p::Word([133u8, 3u8, 18u8, 19u8, 133u8, 3u8, 19u8, 19u8]), + _p::Word([133u8, 3u8, 12u8, 19u8, 133u8, 3u8, 13u8, 19u8]), + _p::Word([133u8, 3u8, 36u8, 19u8, 137u8, 3u8, 37u8, 19u8]), + _p::Word([149u8, 3u8, 30u8, 19u8, 169u8, 3u8, 30u8, 51u8]), + _p::Word([193u8, 3u8, 119u8, 2u8, 19u8, 17u8, 5u8, 19u8]), + _p::Word([0u8, 0u8, 7u8, 102u8, 111u8, 111u8, 7u8, 98u8]), + _p::Word([97u8, 114u8, 255u8, 1u8, 244u8, 128u8, 13u8, 14u8]), + _p::Word([16u8, 76u8, 251u8, 0u8, 63u8, 78u8, 115u8, 232u8]), + _p::Word([56u8, 166u8, 51u8, 253u8, 90u8, 210u8, 4u8, 20u8]), + _p::Word([136u8, 98u8, 3u8, 255u8, 210u8, 10u8, 111u8, 18u8]), + _p::Word([33u8, 25u8, 204u8, 4u8, 0u8, 31u8, 95u8, 112u8]), + _p::Word([9u8, 175u8, 2u8, 224u8, 144u8, 117u8, 64u8, 17u8]), + _p::Word([77u8, 34u8, 17u8, 77u8, 26u8, 81u8, 76u8, 6u8]), + _p::Word([20u8, 19u8, 37u8, 1u8, 24u8, 19u8, 33u8, 1u8]), + _p::Word([41u8, 19u8, 33u8, 1u8, 34u8, 19u8, 33u8, 1u8]), + _p::Word([35u8, 19u8, 33u8, 1u8, 36u8, 19u8, 37u8, 1u8]), + _p::Word([37u8, 19u8, 49u8, 1u8, 34u8, 19u8, 49u8, 1u8]), + _p::Word([35u8, 19u8, 49u8, 1u8, 36u8, 19u8, 53u8, 1u8]), + _p::Word([37u8, 19u8, 65u8, 1u8, 52u8, 19u8, 73u8, 1u8]), + _p::Word([53u8, 19u8, 93u8, 1u8, 30u8, 19u8, 113u8, 1u8]), + _p::Word([30u8, 51u8, 133u8, 1u8, 119u8, 2u8, 19u8, 213u8]), + _p::Word([2u8, 27u8, 0u8, 0u8, 7u8, 98u8, 97u8, 122u8]), + _p::Word([7u8, 113u8, 117u8, 120u8, 0u8, 5u8, 17u8, 77u8]), + _p::Word([58u8, 0u8, 0u8, 81u8, 72u8, 6u8, 20u8, 0u8]), + _p::Word([16u8, 63u8, 110u8, 101u8, 115u8, 116u8, 101u8, 100u8]), + _p::Word([0u8, 5u8, 17u8, 77u8, 114u8, 0u8, 18u8, 255u8]), + _p::Word([114u8, 101u8, 97u8, 108u8, 108u8, 121u8, 32u8, 110u8]), + _p::Word([0u8, 31u8, 101u8, 115u8, 116u8, 101u8, 100u8, 1u8]), + _p::Word([26u8, 15u8, 12u8, 222u8, 128u8, 127u8, 239u8, 210u8]), + _p::Word([4u8, 210u8, 233u8, 128u8, 255u8, 127u8, 247u8, 78u8]), + _p::Word([97u8, 188u8, 64u8, 211u8, 160u8, 250u8, 248u8, 128u8]), + _p::Word([255u8, 255u8, 255u8, 127u8, 63u8, 121u8, 223u8, 13u8]), + _p::Word([134u8, 72u8, 112u8, 255u8, 46u8, 117u8, 19u8, 253u8]), + _p::Word([138u8, 150u8, 253u8, 255u8, 0u8, 128u8, 128u8, 255u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([0u8, 11u8, 12u8, 34u8, 255u8, 207u8, 210u8, 4u8]), + _p::Word([46u8, 22u8, 255u8, 255u8, 247u8, 78u8, 97u8, 188u8]), + _p::Word([192u8, 44u8, 95u8, 5u8, 240u8, 255u8, 255u8, 255u8]), + _p::Word([255u8, 63u8, 121u8, 223u8, 13u8, 134u8, 72u8, 112u8]), + _p::Word([127u8, 210u8, 138u8, 236u8, 2u8, 117u8, 105u8, 2u8]), + _p::Word([0u8, 0u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([255u8, 255u8, 255u8, 0u8, 240u8, 56u8, 180u8, 150u8]), + _p::Word([73u8, 255u8, 194u8, 189u8, 240u8, 124u8, 194u8, 189u8]), + _p::Word([240u8, 252u8, 1u8, 234u8, 28u8, 8u8, 2u8, 234u8]), + _p::Word([28u8, 8u8, 130u8, 0u8, 0u8, 255u8, 64u8, 222u8]), + _p::Word([119u8, 131u8, 33u8, 18u8, 220u8, 66u8, 4u8, 41u8]), + _p::Word([144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 127u8, 41u8]), + _p::Word([144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 255u8, 145u8]), + _p::Word([247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 0u8, 145u8]), + _p::Word([247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 128u8, 17u8]), + _p::Word([9u8, 42u8, 17u8, 9u8, 50u8, 17u8, 9u8, 58u8]), + _p::Word([15u8, 113u8, 117u8, 117u8, 120u8, 31u8, 99u8, 111u8]), + _p::Word([114u8, 103u8, 101u8, 63u8, 103u8, 114u8, 97u8, 117u8]), + _p::Word([108u8, 116u8, 17u8, 9u8, 50u8, 17u8, 9u8, 42u8]), + _p::Word([17u8, 9u8, 34u8, 63u8, 103u8, 97u8, 114u8, 112u8]), + _p::Word([108u8, 121u8, 31u8, 119u8, 97u8, 108u8, 100u8, 111u8]), + _p::Word([15u8, 102u8, 114u8, 101u8, 100u8, 81u8, 12u8, 6u8]), + _p::Word([20u8, 0u8, 5u8, 19u8, 29u8, 1u8, 122u8, 0u8]), + _p::Word([24u8, 17u8, 189u8, 122u8, 0u8, 24u8, 17u8, 93u8]), + _p::Word([122u8, 0u8, 18u8, 255u8, 120u8, 32u8, 115u8, 116u8]), + _p::Word([114u8, 117u8, 99u8, 116u8, 0u8, 63u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 49u8, 255u8, 120u8, 32u8, 115u8]), + _p::Word([116u8, 114u8, 117u8, 99u8, 116u8, 0u8, 63u8, 108u8]), + _p::Word([105u8, 115u8, 116u8, 32u8, 50u8, 255u8, 120u8, 32u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 0u8, 63u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 51u8, 21u8, 3u8]), + _p::Word([1u8, 6u8, 1u8, 9u8, 3u8, 111u8, 145u8, 15u8]), + _p::Word([103u8, 43u8, 153u8, 212u8, 255u8, 199u8, 107u8, 159u8]), + _p::Word([6u8, 57u8, 148u8, 96u8, 249u8, 2u8, 199u8, 113u8]), + _p::Word([196u8, 43u8, 171u8, 117u8, 107u8, 15u8, 57u8, 142u8]), + _p::Word([59u8, 212u8, 84u8, 138u8, 148u8, 240u8, 3u8, 111u8]), + _p::Word([222u8, 15u8, 53u8, 130u8, 156u8, 173u8, 15u8, 85u8]), + _p::Word([161u8, 174u8, 198u8, 255u8, 199u8, 113u8, 172u8, 181u8]), + _p::Word([175u8, 152u8, 50u8, 154u8, 0u8, 206u8, 156u8, 173u8]), + _p::Word([69u8, 128u8, 127u8, 204u8, 128u8, 255u8, 192u8, 127u8]), + _p::Word([240u8, 192u8, 97u8, 190u8, 64u8, 192u8, 240u8, 127u8]), + _p::Word([192u8, 240u8, 255u8, 192u8, 248u8, 127u8, 17u8, 9u8]), + _p::Word([50u8, 17u8, 9u8, 50u8, 17u8, 9u8, 42u8, 31u8]), + _p::Word([112u8, 108u8, 117u8, 103u8, 104u8, 31u8, 120u8, 121u8]), + _p::Word([122u8, 122u8, 121u8, 15u8, 116u8, 104u8, 117u8, 100u8]), + _p::Word([17u8, 9u8, 34u8, 17u8, 9u8, 74u8, 17u8, 13u8]), + _p::Word([58u8, 15u8, 111u8, 111u8, 112u8, 115u8, 255u8, 101u8]), + _p::Word([120u8, 104u8, 97u8, 117u8, 115u8, 116u8, 101u8, 0u8]), + _p::Word([1u8, 100u8, 127u8, 114u8, 102u8, 99u8, 51u8, 48u8]), + _p::Word([57u8, 50u8, 81u8, 12u8, 6u8, 20u8, 0u8, 5u8]), + _p::Word([19u8, 29u8, 1u8, 106u8, 0u8, 24u8, 17u8, 189u8]), + _p::Word([106u8, 0u8, 24u8, 17u8, 93u8, 106u8, 0u8, 18u8]), + _p::Word([255u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8]), + _p::Word([105u8, 0u8, 15u8, 115u8, 116u8, 32u8, 49u8, 255u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([0u8, 15u8, 115u8, 116u8, 32u8, 50u8, 255u8, 115u8]), + _p::Word([116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8, 0u8]), + _p::Word([15u8, 115u8, 116u8, 32u8, 51u8, 4u8, 7u8, 0u8]), + ], + ) +}; +pub const EMBEDDED_TEXT: _p::ty::ConstPtr<_p::Text> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 98u8, 132u8, 0u8, 0u8]), + _p::Word([40u8, 118u8, 111u8, 105u8, 100u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 118u8, 111u8, 105u8]), + _p::Word([100u8, 44u8, 32u8, 98u8, 111u8, 111u8, 108u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 116u8]), + _p::Word([114u8, 117u8, 101u8, 44u8, 32u8, 105u8, 110u8, 116u8]), + _p::Word([56u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 45u8, 49u8, 50u8, 51u8, 44u8, 32u8, 105u8]), + _p::Word([110u8, 116u8, 49u8, 54u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 45u8, 49u8, 50u8, 51u8]), + _p::Word([52u8, 53u8, 44u8, 32u8, 105u8, 110u8, 116u8, 51u8]), + _p::Word([50u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 45u8, 49u8, 50u8, 51u8, 52u8, 53u8, 54u8]), + _p::Word([55u8, 56u8, 44u8, 32u8, 105u8, 110u8, 116u8, 54u8]), + _p::Word([52u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 45u8, 49u8, 50u8, 51u8, 52u8, 53u8, 54u8]), + _p::Word([55u8, 56u8, 57u8, 48u8, 49u8, 50u8, 51u8, 52u8]), + _p::Word([53u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 56u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([50u8, 51u8, 52u8, 44u8, 32u8, 117u8, 73u8, 110u8]), + _p::Word([116u8, 49u8, 54u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 52u8, 53u8, 54u8, 55u8, 56u8]), + _p::Word([44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 51u8, 50u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([51u8, 52u8, 53u8, 54u8, 55u8, 56u8, 57u8, 48u8]), + _p::Word([49u8, 50u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8]), + _p::Word([54u8, 52u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 49u8, 50u8, 51u8, 52u8, 53u8, 54u8]), + _p::Word([55u8, 56u8, 57u8, 48u8, 49u8, 50u8, 51u8, 52u8]), + _p::Word([53u8, 54u8, 55u8, 56u8, 57u8, 48u8, 44u8, 32u8]), + _p::Word([102u8, 108u8, 111u8, 97u8, 116u8, 51u8, 50u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 49u8]), + _p::Word([50u8, 51u8, 52u8, 46u8, 53u8, 44u8, 32u8, 102u8]), + _p::Word([108u8, 111u8, 97u8, 116u8, 54u8, 52u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 45u8, 49u8]), + _p::Word([46u8, 50u8, 51u8, 101u8, 52u8, 55u8, 44u8, 32u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 34u8, 102u8, 111u8, 111u8]), + _p::Word([34u8, 44u8, 32u8, 100u8, 97u8, 116u8, 97u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 34u8]), + _p::Word([98u8, 97u8, 114u8, 34u8, 44u8, 32u8, 115u8, 116u8]), + _p::Word([114u8, 117u8, 99u8, 116u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 40u8, 118u8, 111u8, 105u8]), + _p::Word([100u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 118u8, 111u8, 105u8, 100u8, 44u8, 32u8, 98u8]), + _p::Word([111u8, 111u8, 108u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 116u8, 114u8, 117u8, 101u8, 44u8]), + _p::Word([32u8, 105u8, 110u8, 116u8, 56u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 45u8, 49u8, 50u8]), + _p::Word([44u8, 32u8, 105u8, 110u8, 116u8, 49u8, 54u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 51u8]), + _p::Word([52u8, 53u8, 54u8, 44u8, 32u8, 105u8, 110u8, 116u8]), + _p::Word([51u8, 50u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 45u8, 55u8, 56u8, 57u8, 48u8, 49u8]), + _p::Word([50u8, 51u8, 52u8, 44u8, 32u8, 105u8, 110u8, 116u8]), + _p::Word([54u8, 52u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 53u8, 54u8, 55u8, 56u8, 57u8, 48u8]), + _p::Word([49u8, 50u8, 51u8, 52u8, 53u8, 54u8, 55u8, 56u8]), + _p::Word([44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 56u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 57u8]), + _p::Word([48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 49u8]), + _p::Word([54u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 49u8, 50u8, 51u8, 52u8, 44u8, 32u8, 117u8]), + _p::Word([73u8, 110u8, 116u8, 51u8, 50u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 53u8, 54u8, 55u8]), + _p::Word([56u8, 57u8, 48u8, 49u8, 50u8, 44u8, 32u8, 117u8]), + _p::Word([73u8, 110u8, 116u8, 54u8, 52u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 51u8, 52u8, 53u8]), + _p::Word([54u8, 55u8, 56u8, 57u8, 48u8, 49u8, 50u8, 51u8]), + _p::Word([52u8, 53u8, 54u8, 55u8, 56u8, 57u8, 48u8, 44u8]), + _p::Word([32u8, 102u8, 108u8, 111u8, 97u8, 116u8, 51u8, 50u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([45u8, 49u8, 46u8, 50u8, 53u8, 101u8, 45u8, 49u8]), + _p::Word([48u8, 44u8, 32u8, 102u8, 108u8, 111u8, 97u8, 116u8]), + _p::Word([54u8, 52u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 51u8, 52u8, 53u8, 44u8, 32u8, 116u8]), + _p::Word([101u8, 120u8, 116u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 34u8, 98u8, 97u8, 122u8, 34u8]), + _p::Word([44u8, 32u8, 100u8, 97u8, 116u8, 97u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 34u8, 113u8]), + _p::Word([117u8, 120u8, 34u8, 44u8, 32u8, 115u8, 116u8, 114u8]), + _p::Word([117u8, 99u8, 116u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 40u8, 118u8, 111u8, 105u8, 100u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([118u8, 111u8, 105u8, 100u8, 44u8, 32u8, 98u8, 111u8]), + _p::Word([111u8, 108u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 102u8, 97u8, 108u8, 115u8, 101u8, 44u8]), + _p::Word([32u8, 105u8, 110u8, 116u8, 56u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([105u8, 110u8, 116u8, 49u8, 54u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([105u8, 110u8, 116u8, 51u8, 50u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([105u8, 110u8, 116u8, 54u8, 52u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([117u8, 73u8, 110u8, 116u8, 56u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([117u8, 73u8, 110u8, 116u8, 49u8, 54u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 117u8, 73u8, 110u8, 116u8, 51u8, 50u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 54u8, 52u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 102u8, 108u8, 111u8, 97u8, 116u8]), + _p::Word([51u8, 50u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 48u8, 44u8, 32u8, 102u8, 108u8, 111u8]), + _p::Word([97u8, 116u8, 54u8, 52u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 116u8]), + _p::Word([101u8, 120u8, 116u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 34u8, 110u8, 101u8, 115u8, 116u8]), + _p::Word([101u8, 100u8, 34u8, 44u8, 32u8, 115u8, 116u8, 114u8]), + _p::Word([117u8, 99u8, 116u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 40u8, 118u8, 111u8, 105u8, 100u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([118u8, 111u8, 105u8, 100u8, 44u8, 32u8, 98u8, 111u8]), + _p::Word([111u8, 108u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 102u8, 97u8, 108u8, 115u8, 101u8, 44u8]), + _p::Word([32u8, 105u8, 110u8, 116u8, 56u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([105u8, 110u8, 116u8, 49u8, 54u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([105u8, 110u8, 116u8, 51u8, 50u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([105u8, 110u8, 116u8, 54u8, 52u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([117u8, 73u8, 110u8, 116u8, 56u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([117u8, 73u8, 110u8, 116u8, 49u8, 54u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 117u8, 73u8, 110u8, 116u8, 51u8, 50u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 54u8, 52u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 102u8, 108u8, 111u8, 97u8, 116u8]), + _p::Word([51u8, 50u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 48u8, 44u8, 32u8, 102u8, 108u8, 111u8]), + _p::Word([97u8, 116u8, 54u8, 52u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 116u8]), + _p::Word([101u8, 120u8, 116u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 34u8, 114u8, 101u8, 97u8, 108u8]), + _p::Word([108u8, 121u8, 32u8, 110u8, 101u8, 115u8, 116u8, 101u8]), + _p::Word([100u8, 34u8, 44u8, 32u8, 101u8, 110u8, 117u8, 109u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([102u8, 111u8, 111u8, 44u8, 32u8, 105u8, 110u8, 116u8]), + _p::Word([101u8, 114u8, 102u8, 97u8, 99u8, 101u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 118u8, 111u8]), + _p::Word([105u8, 100u8, 41u8, 44u8, 32u8, 101u8, 110u8, 117u8]), + _p::Word([109u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 102u8, 111u8, 111u8, 44u8, 32u8, 105u8, 110u8]), + _p::Word([116u8, 101u8, 114u8, 102u8, 97u8, 99u8, 101u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 118u8]), + _p::Word([111u8, 105u8, 100u8, 41u8, 44u8, 32u8, 101u8, 110u8]), + _p::Word([117u8, 109u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 98u8, 97u8, 122u8, 44u8, 32u8, 105u8]), + _p::Word([110u8, 116u8, 101u8, 114u8, 102u8, 97u8, 99u8, 101u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([118u8, 111u8, 105u8, 100u8, 44u8, 32u8, 118u8, 111u8]), + _p::Word([105u8, 100u8, 76u8, 105u8, 115u8, 116u8, 32u8, 61u8]), + _p::Word([32u8, 91u8, 118u8, 111u8, 105u8, 100u8, 44u8, 32u8]), + _p::Word([118u8, 111u8, 105u8, 100u8, 44u8, 32u8, 118u8, 111u8]), + _p::Word([105u8, 100u8, 93u8, 44u8, 32u8, 98u8, 111u8, 111u8]), + _p::Word([108u8, 76u8, 105u8, 115u8, 116u8, 32u8, 61u8, 32u8]), + _p::Word([91u8, 102u8, 97u8, 108u8, 115u8, 101u8, 44u8, 32u8]), + _p::Word([116u8, 114u8, 117u8, 101u8, 44u8, 32u8, 102u8, 97u8]), + _p::Word([108u8, 115u8, 101u8, 44u8, 32u8, 116u8, 114u8, 117u8]), + _p::Word([101u8, 44u8, 32u8, 116u8, 114u8, 117u8, 101u8, 93u8]), + _p::Word([44u8, 32u8, 105u8, 110u8, 116u8, 56u8, 76u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 49u8, 50u8]), + _p::Word([44u8, 32u8, 45u8, 51u8, 52u8, 44u8, 32u8, 45u8]), + _p::Word([49u8, 50u8, 56u8, 44u8, 32u8, 49u8, 50u8, 55u8]), + _p::Word([93u8, 44u8, 32u8, 105u8, 110u8, 116u8, 49u8, 54u8]), + _p::Word([76u8, 105u8, 115u8, 116u8, 32u8, 61u8, 32u8, 91u8]), + _p::Word([49u8, 50u8, 51u8, 52u8, 44u8, 32u8, 45u8, 53u8]), + _p::Word([54u8, 55u8, 56u8, 44u8, 32u8, 45u8, 51u8, 50u8]), + _p::Word([55u8, 54u8, 56u8, 44u8, 32u8, 51u8, 50u8, 55u8]), + _p::Word([54u8, 55u8, 93u8, 44u8, 32u8, 105u8, 110u8, 116u8]), + _p::Word([51u8, 50u8, 76u8, 105u8, 115u8, 116u8, 32u8, 61u8]), + _p::Word([32u8, 91u8, 49u8, 50u8, 51u8, 52u8, 53u8, 54u8]), + _p::Word([55u8, 56u8, 44u8, 32u8, 45u8, 57u8, 48u8, 49u8]), + _p::Word([50u8, 51u8, 52u8, 53u8, 54u8, 44u8, 32u8, 45u8]), + _p::Word([50u8, 49u8, 52u8, 55u8, 52u8, 56u8, 51u8, 54u8]), + _p::Word([52u8, 56u8, 44u8, 32u8, 50u8, 49u8, 52u8, 55u8]), + _p::Word([52u8, 56u8, 51u8, 54u8, 52u8, 55u8, 93u8, 44u8]), + _p::Word([32u8, 105u8, 110u8, 116u8, 54u8, 52u8, 76u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 49u8, 50u8]), + _p::Word([51u8, 52u8, 53u8, 54u8, 55u8, 56u8, 57u8, 48u8]), + _p::Word([49u8, 50u8, 51u8, 52u8, 53u8, 44u8, 32u8, 45u8]), + _p::Word([54u8, 55u8, 56u8, 57u8, 48u8, 49u8, 50u8, 51u8]), + _p::Word([52u8, 53u8, 54u8, 55u8, 56u8, 57u8, 48u8, 44u8]), + _p::Word([32u8, 45u8, 57u8, 50u8, 50u8, 51u8, 51u8, 55u8]), + _p::Word([50u8, 48u8, 51u8, 54u8, 56u8, 53u8, 52u8, 55u8]), + _p::Word([55u8, 53u8, 56u8, 48u8, 56u8, 44u8, 32u8, 57u8]), + _p::Word([50u8, 50u8, 51u8, 51u8, 55u8, 50u8, 48u8, 51u8]), + _p::Word([54u8, 56u8, 53u8, 52u8, 55u8, 55u8, 53u8, 56u8]), + _p::Word([48u8, 55u8, 93u8, 44u8, 32u8, 117u8, 73u8, 110u8]), + _p::Word([116u8, 56u8, 76u8, 105u8, 115u8, 116u8, 32u8, 61u8]), + _p::Word([32u8, 91u8, 49u8, 50u8, 44u8, 32u8, 51u8, 52u8]), + _p::Word([44u8, 32u8, 48u8, 44u8, 32u8, 50u8, 53u8, 53u8]), + _p::Word([93u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 49u8]), + _p::Word([54u8, 76u8, 105u8, 115u8, 116u8, 32u8, 61u8, 32u8]), + _p::Word([91u8, 49u8, 50u8, 51u8, 52u8, 44u8, 32u8, 53u8]), + _p::Word([54u8, 55u8, 56u8, 44u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([54u8, 53u8, 53u8, 51u8, 53u8, 93u8, 44u8, 32u8]), + _p::Word([117u8, 73u8, 110u8, 116u8, 51u8, 50u8, 76u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 49u8, 50u8]), + _p::Word([51u8, 52u8, 53u8, 54u8, 55u8, 56u8, 44u8, 32u8]), + _p::Word([57u8, 48u8, 49u8, 50u8, 51u8, 52u8, 53u8, 54u8]), + _p::Word([44u8, 32u8, 48u8, 44u8, 32u8, 52u8, 50u8, 57u8]), + _p::Word([52u8, 57u8, 54u8, 55u8, 50u8, 57u8, 53u8, 93u8]), + _p::Word([44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 54u8, 52u8]), + _p::Word([76u8, 105u8, 115u8, 116u8, 32u8, 61u8, 32u8, 91u8]), + _p::Word([49u8, 50u8, 51u8, 52u8, 53u8, 54u8, 55u8, 56u8]), + _p::Word([57u8, 48u8, 49u8, 50u8, 51u8, 52u8, 53u8, 44u8]), + _p::Word([32u8, 54u8, 55u8, 56u8, 57u8, 48u8, 49u8, 50u8]), + _p::Word([51u8, 52u8, 53u8, 54u8, 55u8, 56u8, 57u8, 48u8]), + _p::Word([44u8, 32u8, 48u8, 44u8, 32u8, 49u8, 56u8, 52u8]), + _p::Word([52u8, 54u8, 55u8, 52u8, 52u8, 48u8, 55u8, 51u8]), + _p::Word([55u8, 48u8, 57u8, 53u8, 53u8, 49u8, 54u8, 49u8]), + _p::Word([53u8, 93u8, 44u8, 32u8, 102u8, 108u8, 111u8, 97u8]), + _p::Word([116u8, 51u8, 50u8, 76u8, 105u8, 115u8, 116u8, 32u8]), + _p::Word([61u8, 32u8, 91u8, 48u8, 44u8, 32u8, 49u8, 50u8]), + _p::Word([51u8, 52u8, 53u8, 54u8, 55u8, 44u8, 32u8, 49u8]), + _p::Word([101u8, 51u8, 55u8, 44u8, 32u8, 45u8, 49u8, 101u8]), + _p::Word([51u8, 55u8, 44u8, 32u8, 49u8, 101u8, 45u8, 51u8]), + _p::Word([55u8, 44u8, 32u8, 45u8, 49u8, 101u8, 45u8, 51u8]), + _p::Word([55u8, 93u8, 44u8, 32u8, 102u8, 108u8, 111u8, 97u8]), + _p::Word([116u8, 54u8, 52u8, 76u8, 105u8, 115u8, 116u8, 32u8]), + _p::Word([61u8, 32u8, 91u8, 48u8, 44u8, 32u8, 49u8, 50u8]), + _p::Word([51u8, 52u8, 53u8, 54u8, 55u8, 56u8, 57u8, 48u8]), + _p::Word([49u8, 50u8, 51u8, 52u8, 53u8, 44u8, 32u8, 49u8]), + _p::Word([101u8, 51u8, 48u8, 54u8, 44u8, 32u8, 45u8, 49u8]), + _p::Word([101u8, 51u8, 48u8, 54u8, 44u8, 32u8, 49u8, 101u8]), + _p::Word([45u8, 51u8, 48u8, 54u8, 44u8, 32u8, 45u8, 49u8]), + _p::Word([101u8, 45u8, 51u8, 48u8, 54u8, 93u8, 44u8, 32u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 76u8, 105u8, 115u8, 116u8]), + _p::Word([32u8, 61u8, 32u8, 91u8, 34u8, 113u8, 117u8, 117u8]), + _p::Word([120u8, 34u8, 44u8, 32u8, 34u8, 99u8, 111u8, 114u8]), + _p::Word([103u8, 101u8, 34u8, 44u8, 32u8, 34u8, 103u8, 114u8]), + _p::Word([97u8, 117u8, 108u8, 116u8, 34u8, 93u8, 44u8, 32u8]), + _p::Word([100u8, 97u8, 116u8, 97u8, 76u8, 105u8, 115u8, 116u8]), + _p::Word([32u8, 61u8, 32u8, 91u8, 34u8, 103u8, 97u8, 114u8]), + _p::Word([112u8, 108u8, 121u8, 34u8, 44u8, 32u8, 34u8, 119u8]), + _p::Word([97u8, 108u8, 100u8, 111u8, 34u8, 44u8, 32u8, 34u8]), + _p::Word([102u8, 114u8, 101u8, 100u8, 34u8, 93u8, 44u8, 32u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 76u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 40u8, 118u8]), + _p::Word([111u8, 105u8, 100u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 118u8, 111u8, 105u8, 100u8, 44u8]), + _p::Word([32u8, 98u8, 111u8, 111u8, 108u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 102u8, 97u8, 108u8]), + _p::Word([115u8, 101u8, 44u8, 32u8, 105u8, 110u8, 116u8, 56u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 105u8, 110u8, 116u8, 49u8, 54u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 105u8, 110u8, 116u8, 51u8, 50u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 105u8, 110u8, 116u8, 54u8, 52u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 56u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 49u8]), + _p::Word([54u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8]), + _p::Word([51u8, 50u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 48u8, 44u8, 32u8, 117u8, 73u8, 110u8]), + _p::Word([116u8, 54u8, 52u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 102u8, 108u8]), + _p::Word([111u8, 97u8, 116u8, 51u8, 50u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([102u8, 108u8, 111u8, 97u8, 116u8, 54u8, 52u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 116u8, 101u8, 120u8, 116u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 34u8, 120u8]), + _p::Word([32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8]), + _p::Word([105u8, 115u8, 116u8, 32u8, 49u8, 34u8, 44u8, 32u8]), + _p::Word([101u8, 110u8, 117u8, 109u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 102u8, 111u8, 111u8, 44u8]), + _p::Word([32u8, 105u8, 110u8, 116u8, 101u8, 114u8, 102u8, 97u8]), + _p::Word([99u8, 101u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 118u8, 111u8, 105u8, 100u8, 41u8, 44u8]), + _p::Word([32u8, 40u8, 118u8, 111u8, 105u8, 100u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 118u8, 111u8]), + _p::Word([105u8, 100u8, 44u8, 32u8, 98u8, 111u8, 111u8, 108u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([102u8, 97u8, 108u8, 115u8, 101u8, 44u8, 32u8, 105u8]), + _p::Word([110u8, 116u8, 56u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 105u8, 110u8]), + _p::Word([116u8, 49u8, 54u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 105u8, 110u8]), + _p::Word([116u8, 51u8, 50u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 105u8, 110u8]), + _p::Word([116u8, 54u8, 52u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 117u8, 73u8]), + _p::Word([110u8, 116u8, 56u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 117u8, 73u8]), + _p::Word([110u8, 116u8, 49u8, 54u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 117u8]), + _p::Word([73u8, 110u8, 116u8, 51u8, 50u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([117u8, 73u8, 110u8, 116u8, 54u8, 52u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 102u8, 108u8, 111u8, 97u8, 116u8, 51u8, 50u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 102u8, 108u8, 111u8, 97u8, 116u8]), + _p::Word([54u8, 52u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 48u8, 44u8, 32u8, 116u8, 101u8, 120u8]), + _p::Word([116u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 34u8, 120u8, 32u8, 115u8, 116u8, 114u8, 117u8]), + _p::Word([99u8, 116u8, 108u8, 105u8, 115u8, 116u8, 32u8, 50u8]), + _p::Word([34u8, 44u8, 32u8, 101u8, 110u8, 117u8, 109u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 102u8]), + _p::Word([111u8, 111u8, 44u8, 32u8, 105u8, 110u8, 116u8, 101u8]), + _p::Word([114u8, 102u8, 97u8, 99u8, 101u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 118u8, 111u8, 105u8]), + _p::Word([100u8, 41u8, 44u8, 32u8, 40u8, 118u8, 111u8, 105u8]), + _p::Word([100u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 118u8, 111u8, 105u8, 100u8, 44u8, 32u8, 98u8]), + _p::Word([111u8, 111u8, 108u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 102u8, 97u8, 108u8, 115u8, 101u8]), + _p::Word([44u8, 32u8, 105u8, 110u8, 116u8, 56u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 105u8, 110u8, 116u8, 49u8, 54u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 105u8, 110u8, 116u8, 51u8, 50u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 105u8, 110u8, 116u8, 54u8, 52u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 117u8, 73u8, 110u8, 116u8, 56u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 117u8, 73u8, 110u8, 116u8, 49u8, 54u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 51u8, 50u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 54u8]), + _p::Word([52u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 48u8, 44u8, 32u8, 102u8, 108u8, 111u8, 97u8]), + _p::Word([116u8, 51u8, 50u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 102u8, 108u8]), + _p::Word([111u8, 97u8, 116u8, 54u8, 52u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([116u8, 101u8, 120u8, 116u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 34u8, 120u8, 32u8, 115u8]), + _p::Word([116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8, 115u8]), + _p::Word([116u8, 32u8, 51u8, 34u8, 44u8, 32u8, 101u8, 110u8]), + _p::Word([117u8, 109u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 102u8, 111u8, 111u8, 44u8, 32u8, 105u8]), + _p::Word([110u8, 116u8, 101u8, 114u8, 102u8, 97u8, 99u8, 101u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([118u8, 111u8, 105u8, 100u8, 41u8, 93u8, 44u8, 32u8]), + _p::Word([101u8, 110u8, 117u8, 109u8, 76u8, 105u8, 115u8, 116u8]), + _p::Word([32u8, 61u8, 32u8, 91u8, 113u8, 117u8, 120u8, 44u8]), + _p::Word([32u8, 98u8, 97u8, 114u8, 44u8, 32u8, 103u8, 114u8]), + _p::Word([97u8, 117u8, 108u8, 116u8, 93u8, 41u8, 44u8, 32u8]), + _p::Word([101u8, 110u8, 117u8, 109u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 99u8, 111u8, 114u8, 103u8]), + _p::Word([101u8, 44u8, 32u8, 105u8, 110u8, 116u8, 101u8, 114u8]), + _p::Word([102u8, 97u8, 99u8, 101u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 118u8, 111u8, 105u8, 100u8]), + _p::Word([44u8, 32u8, 118u8, 111u8, 105u8, 100u8, 76u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 118u8, 111u8]), + _p::Word([105u8, 100u8, 44u8, 32u8, 118u8, 111u8, 105u8, 100u8]), + _p::Word([44u8, 32u8, 118u8, 111u8, 105u8, 100u8, 44u8, 32u8]), + _p::Word([118u8, 111u8, 105u8, 100u8, 44u8, 32u8, 118u8, 111u8]), + _p::Word([105u8, 100u8, 44u8, 32u8, 118u8, 111u8, 105u8, 100u8]), + _p::Word([93u8, 44u8, 32u8, 98u8, 111u8, 111u8, 108u8, 76u8]), + _p::Word([105u8, 115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 116u8]), + _p::Word([114u8, 117u8, 101u8, 44u8, 32u8, 102u8, 97u8, 108u8]), + _p::Word([115u8, 101u8, 44u8, 32u8, 102u8, 97u8, 108u8, 115u8]), + _p::Word([101u8, 44u8, 32u8, 116u8, 114u8, 117u8, 101u8, 93u8]), + _p::Word([44u8, 32u8, 105u8, 110u8, 116u8, 56u8, 76u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 49u8, 49u8]), + _p::Word([49u8, 44u8, 32u8, 45u8, 49u8, 49u8, 49u8, 93u8]), + _p::Word([44u8, 32u8, 105u8, 110u8, 116u8, 49u8, 54u8, 76u8]), + _p::Word([105u8, 115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 49u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 44u8, 32u8, 45u8, 49u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 93u8, 44u8, 32u8, 105u8]), + _p::Word([110u8, 116u8, 51u8, 50u8, 76u8, 105u8, 115u8, 116u8]), + _p::Word([32u8, 61u8, 32u8, 91u8, 49u8, 49u8, 49u8, 49u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 49u8, 44u8, 32u8, 45u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8]), + _p::Word([49u8, 93u8, 44u8, 32u8, 105u8, 110u8, 116u8, 54u8]), + _p::Word([52u8, 76u8, 105u8, 115u8, 116u8, 32u8, 61u8, 32u8]), + _p::Word([91u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 44u8, 32u8, 45u8, 49u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8]), + _p::Word([49u8, 49u8, 93u8, 44u8, 32u8, 117u8, 73u8, 110u8]), + _p::Word([116u8, 56u8, 76u8, 105u8, 115u8, 116u8, 32u8, 61u8]), + _p::Word([32u8, 91u8, 49u8, 49u8, 49u8, 44u8, 32u8, 50u8]), + _p::Word([50u8, 50u8, 93u8, 44u8, 32u8, 117u8, 73u8, 110u8]), + _p::Word([116u8, 49u8, 54u8, 76u8, 105u8, 115u8, 116u8, 32u8]), + _p::Word([61u8, 32u8, 91u8, 51u8, 51u8, 51u8, 51u8, 51u8]), + _p::Word([44u8, 32u8, 52u8, 52u8, 52u8, 52u8, 52u8, 93u8]), + _p::Word([44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 51u8, 50u8]), + _p::Word([76u8, 105u8, 115u8, 116u8, 32u8, 61u8, 32u8, 91u8]), + _p::Word([51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8]), + _p::Word([51u8, 51u8, 93u8, 44u8, 32u8, 117u8, 73u8, 110u8]), + _p::Word([116u8, 54u8, 52u8, 76u8, 105u8, 115u8, 116u8, 32u8]), + _p::Word([61u8, 32u8, 91u8, 49u8, 49u8, 49u8, 49u8, 49u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8]), + _p::Word([49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 49u8, 93u8]), + _p::Word([44u8, 32u8, 102u8, 108u8, 111u8, 97u8, 116u8, 51u8]), + _p::Word([50u8, 76u8, 105u8, 115u8, 116u8, 32u8, 61u8, 32u8]), + _p::Word([91u8, 53u8, 53u8, 53u8, 53u8, 46u8, 53u8, 44u8]), + _p::Word([32u8, 105u8, 110u8, 102u8, 44u8, 32u8, 45u8, 105u8]), + _p::Word([110u8, 102u8, 44u8, 32u8, 110u8, 97u8, 110u8, 93u8]), + _p::Word([44u8, 32u8, 102u8, 108u8, 111u8, 97u8, 116u8, 54u8]), + _p::Word([52u8, 76u8, 105u8, 115u8, 116u8, 32u8, 61u8, 32u8]), + _p::Word([91u8, 55u8, 55u8, 55u8, 55u8, 46u8, 55u8, 53u8]), + _p::Word([44u8, 32u8, 105u8, 110u8, 102u8, 44u8, 32u8, 45u8]), + _p::Word([105u8, 110u8, 102u8, 44u8, 32u8, 110u8, 97u8, 110u8]), + _p::Word([93u8, 44u8, 32u8, 116u8, 101u8, 120u8, 116u8, 76u8]), + _p::Word([105u8, 115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 34u8]), + _p::Word([112u8, 108u8, 117u8, 103u8, 104u8, 34u8, 44u8, 32u8]), + _p::Word([34u8, 120u8, 121u8, 122u8, 122u8, 121u8, 34u8, 44u8]), + _p::Word([32u8, 34u8, 116u8, 104u8, 117u8, 100u8, 34u8, 93u8]), + _p::Word([44u8, 32u8, 100u8, 97u8, 116u8, 97u8, 76u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 61u8, 32u8, 91u8, 34u8, 111u8]), + _p::Word([111u8, 112u8, 115u8, 34u8, 44u8, 32u8, 34u8, 101u8]), + _p::Word([120u8, 104u8, 97u8, 117u8, 115u8, 116u8, 101u8, 100u8]), + _p::Word([34u8, 44u8, 32u8, 34u8, 114u8, 102u8, 99u8, 51u8]), + _p::Word([48u8, 57u8, 50u8, 34u8, 93u8, 44u8, 32u8, 115u8]), + _p::Word([116u8, 114u8, 117u8, 99u8, 116u8, 76u8, 105u8, 115u8]), + _p::Word([116u8, 32u8, 61u8, 32u8, 91u8, 40u8, 118u8, 111u8]), + _p::Word([105u8, 100u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 118u8, 111u8, 105u8, 100u8, 44u8, 32u8]), + _p::Word([98u8, 111u8, 111u8, 108u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 102u8, 97u8, 108u8, 115u8]), + _p::Word([101u8, 44u8, 32u8, 105u8, 110u8, 116u8, 56u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 105u8, 110u8, 116u8, 49u8, 54u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 105u8, 110u8, 116u8, 51u8, 50u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 105u8, 110u8, 116u8, 54u8, 52u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 56u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 49u8, 54u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 51u8]), + _p::Word([50u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8]), + _p::Word([54u8, 52u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 48u8, 44u8, 32u8, 102u8, 108u8, 111u8]), + _p::Word([97u8, 116u8, 51u8, 50u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 102u8]), + _p::Word([108u8, 111u8, 97u8, 116u8, 54u8, 52u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 116u8, 101u8, 120u8, 116u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 34u8, 115u8, 116u8]), + _p::Word([114u8, 117u8, 99u8, 116u8, 108u8, 105u8, 115u8, 116u8]), + _p::Word([32u8, 49u8, 34u8, 44u8, 32u8, 101u8, 110u8, 117u8]), + _p::Word([109u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 102u8, 111u8, 111u8, 44u8, 32u8, 105u8, 110u8]), + _p::Word([116u8, 101u8, 114u8, 102u8, 97u8, 99u8, 101u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 118u8]), + _p::Word([111u8, 105u8, 100u8, 41u8, 44u8, 32u8, 40u8, 118u8]), + _p::Word([111u8, 105u8, 100u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 118u8, 111u8, 105u8, 100u8, 44u8]), + _p::Word([32u8, 98u8, 111u8, 111u8, 108u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 102u8, 97u8, 108u8]), + _p::Word([115u8, 101u8, 44u8, 32u8, 105u8, 110u8, 116u8, 56u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 105u8, 110u8, 116u8, 49u8, 54u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 105u8, 110u8, 116u8, 51u8, 50u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 105u8, 110u8, 116u8, 54u8, 52u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 56u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8, 49u8]), + _p::Word([54u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8]), + _p::Word([51u8, 50u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 48u8, 44u8, 32u8, 117u8, 73u8, 110u8]), + _p::Word([116u8, 54u8, 52u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 102u8, 108u8]), + _p::Word([111u8, 97u8, 116u8, 51u8, 50u8, 70u8, 105u8, 101u8]), + _p::Word([108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8]), + _p::Word([102u8, 108u8, 111u8, 97u8, 116u8, 54u8, 52u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8]), + _p::Word([44u8, 32u8, 116u8, 101u8, 120u8, 116u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 34u8, 115u8]), + _p::Word([116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8, 115u8]), + _p::Word([116u8, 32u8, 50u8, 34u8, 44u8, 32u8, 101u8, 110u8]), + _p::Word([117u8, 109u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 102u8, 111u8, 111u8, 44u8, 32u8, 105u8]), + _p::Word([110u8, 116u8, 101u8, 114u8, 102u8, 97u8, 99u8, 101u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([118u8, 111u8, 105u8, 100u8, 41u8, 44u8, 32u8, 40u8]), + _p::Word([118u8, 111u8, 105u8, 100u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 118u8, 111u8, 105u8, 100u8]), + _p::Word([44u8, 32u8, 98u8, 111u8, 111u8, 108u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 102u8, 97u8]), + _p::Word([108u8, 115u8, 101u8, 44u8, 32u8, 105u8, 110u8, 116u8]), + _p::Word([56u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 48u8, 44u8, 32u8, 105u8, 110u8, 116u8, 49u8]), + _p::Word([54u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 48u8, 44u8, 32u8, 105u8, 110u8, 116u8, 51u8]), + _p::Word([50u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 48u8, 44u8, 32u8, 105u8, 110u8, 116u8, 54u8]), + _p::Word([52u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8]), + _p::Word([56u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 48u8, 44u8, 32u8, 117u8, 73u8, 110u8, 116u8]), + _p::Word([49u8, 54u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8]), + _p::Word([61u8, 32u8, 48u8, 44u8, 32u8, 117u8, 73u8, 110u8]), + _p::Word([116u8, 51u8, 50u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 117u8, 73u8]), + _p::Word([110u8, 116u8, 54u8, 52u8, 70u8, 105u8, 101u8, 108u8]), + _p::Word([100u8, 32u8, 61u8, 32u8, 48u8, 44u8, 32u8, 102u8]), + _p::Word([108u8, 111u8, 97u8, 116u8, 51u8, 50u8, 70u8, 105u8]), + _p::Word([101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 48u8, 44u8]), + _p::Word([32u8, 102u8, 108u8, 111u8, 97u8, 116u8, 54u8, 52u8]), + _p::Word([70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8]), + _p::Word([48u8, 44u8, 32u8, 116u8, 101u8, 120u8, 116u8, 70u8]), + _p::Word([105u8, 101u8, 108u8, 100u8, 32u8, 61u8, 32u8, 34u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 51u8, 34u8, 44u8, 32u8, 101u8]), + _p::Word([110u8, 117u8, 109u8, 70u8, 105u8, 101u8, 108u8, 100u8]), + _p::Word([32u8, 61u8, 32u8, 102u8, 111u8, 111u8, 44u8, 32u8]), + _p::Word([105u8, 110u8, 116u8, 101u8, 114u8, 102u8, 97u8, 99u8]), + _p::Word([101u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 61u8]), + _p::Word([32u8, 118u8, 111u8, 105u8, 100u8, 41u8, 93u8, 44u8]), + _p::Word([32u8, 101u8, 110u8, 117u8, 109u8, 76u8, 105u8, 115u8]), + _p::Word([116u8, 32u8, 61u8, 32u8, 91u8, 102u8, 111u8, 111u8]), + _p::Word([44u8, 32u8, 103u8, 97u8, 114u8, 112u8, 108u8, 121u8]), + _p::Word([93u8, 41u8, 10u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) +}; +pub const EMBEDDED_STRUCT: _p::ty::ConstPtr<_p::Struct> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([1u8, 133u8, 199u8, 207u8, 178u8, 158u8, 67u8, 255u8]), + _p::Word([135u8, 32u8, 242u8, 121u8, 183u8, 143u8, 255u8, 255u8]), + _p::Word([234u8, 0u8, 110u8, 178u8, 20u8, 106u8, 10u8, 206u8]), + _p::Word([210u8, 10u8, 31u8, 235u8, 140u8, 169u8, 84u8, 171u8]), + _p::Word([0u8, 80u8, 154u8, 68u8, 5u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 187u8, 224u8, 192u8, 130u8, 139u8, 181u8, 201u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 26u8, 0u8, 0u8, 0u8]), + _p::Word([76u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 48u8, 0u8, 0u8, 0u8]), + _p::Word([129u8, 3u8, 0u8, 0u8, 33u8, 0u8, 0u8, 0u8]), + _p::Word([129u8, 3u8, 0u8, 0u8, 18u8, 0u8, 0u8, 0u8]), + _p::Word([129u8, 3u8, 0u8, 0u8, 19u8, 0u8, 0u8, 0u8]), + _p::Word([129u8, 3u8, 0u8, 0u8, 20u8, 0u8, 0u8, 0u8]), + _p::Word([129u8, 3u8, 0u8, 0u8, 21u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 3u8, 0u8, 0u8, 18u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 3u8, 0u8, 0u8, 19u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 3u8, 0u8, 0u8, 12u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 3u8, 0u8, 0u8, 13u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 3u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([137u8, 3u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([149u8, 3u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([169u8, 3u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([193u8, 3u8, 0u8, 0u8, 119u8, 2u8, 0u8, 0u8]), + _p::Word([17u8, 5u8, 0u8, 0u8, 19u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 114u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 244u8, 128u8, 13u8, 14u8, 16u8, 76u8, 251u8]), + _p::Word([78u8, 115u8, 232u8, 56u8, 166u8, 51u8, 0u8, 0u8]), + _p::Word([90u8, 0u8, 210u8, 4u8, 20u8, 136u8, 98u8, 3u8]), + _p::Word([210u8, 10u8, 111u8, 18u8, 33u8, 25u8, 204u8, 4u8]), + _p::Word([95u8, 112u8, 9u8, 175u8, 2u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 144u8, 117u8, 64u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 26u8, 0u8, 0u8, 0u8]), + _p::Word([76u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 24u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 41u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([37u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([53u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([65u8, 1u8, 0u8, 0u8, 52u8, 0u8, 0u8, 0u8]), + _p::Word([73u8, 1u8, 0u8, 0u8, 53u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 1u8, 0u8, 0u8, 119u8, 2u8, 0u8, 0u8]), + _p::Word([213u8, 2u8, 0u8, 0u8, 27u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 122u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([72u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([110u8, 101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 114u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([114u8, 101u8, 97u8, 108u8, 108u8, 121u8, 32u8, 110u8]), + _p::Word([101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8, 0u8]), + _p::Word([26u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 222u8, 128u8, 127u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 210u8, 233u8, 0u8, 128u8, 255u8, 127u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 64u8, 211u8, 160u8, 250u8]), + _p::Word([0u8, 0u8, 0u8, 128u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([46u8, 117u8, 19u8, 253u8, 138u8, 150u8, 253u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 128u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([12u8, 34u8, 0u8, 255u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 46u8, 22u8, 0u8, 0u8, 255u8, 255u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 192u8, 44u8, 95u8, 5u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([210u8, 138u8, 236u8, 2u8, 117u8, 105u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 56u8, 180u8, 150u8, 73u8]), + _p::Word([194u8, 189u8, 240u8, 124u8, 194u8, 189u8, 240u8, 252u8]), + _p::Word([234u8, 28u8, 8u8, 2u8, 234u8, 28u8, 8u8, 130u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([64u8, 222u8, 119u8, 131u8, 33u8, 18u8, 220u8, 66u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 127u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 255u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 0u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 128u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([99u8, 111u8, 114u8, 103u8, 101u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 114u8, 97u8, 117u8, 108u8, 116u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 97u8, 114u8, 112u8, 108u8, 121u8, 0u8, 0u8]), + _p::Word([119u8, 97u8, 108u8, 100u8, 111u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 114u8, 101u8, 100u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 49u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 50u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 51u8, 0u8, 0u8]), + _p::Word([3u8, 0u8, 1u8, 0u8, 6u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([111u8, 145u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 43u8, 153u8, 212u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([199u8, 107u8, 159u8, 6u8, 57u8, 148u8, 96u8, 249u8]), + _p::Word([199u8, 113u8, 196u8, 43u8, 171u8, 117u8, 107u8, 15u8]), + _p::Word([57u8, 142u8, 59u8, 212u8, 84u8, 138u8, 148u8, 240u8]), + _p::Word([111u8, 222u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([53u8, 130u8, 156u8, 173u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([85u8, 161u8, 174u8, 198u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([199u8, 113u8, 172u8, 181u8, 175u8, 152u8, 50u8, 154u8]), + _p::Word([0u8, 156u8, 173u8, 69u8, 0u8, 0u8, 128u8, 127u8]), + _p::Word([0u8, 0u8, 128u8, 255u8, 0u8, 0u8, 192u8, 127u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 192u8, 97u8, 190u8, 64u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 240u8, 127u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 240u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 248u8, 127u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([112u8, 108u8, 117u8, 103u8, 104u8, 0u8, 0u8, 0u8]), + _p::Word([120u8, 121u8, 122u8, 122u8, 121u8, 0u8, 0u8, 0u8]), + _p::Word([116u8, 104u8, 117u8, 100u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 74u8, 0u8, 0u8, 0u8]), + _p::Word([13u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([111u8, 111u8, 112u8, 115u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([101u8, 120u8, 104u8, 97u8, 117u8, 115u8, 116u8, 101u8]), + _p::Word([100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([114u8, 102u8, 99u8, 51u8, 48u8, 57u8, 50u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 106u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 49u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 50u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 108u8, 105u8]), + _p::Word([115u8, 116u8, 32u8, 51u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 7u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) +}; +pub const NON_ASCII_TEXT: _p::ty::ConstPtr<_p::Text> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 90u8, 0u8, 0u8, 0u8]), + _p::Word([226u8, 153u8, 171u8, 32u8, 195u8, 169u8, 32u8, 226u8]), + _p::Word([156u8, 147u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) +}; +pub const BLOCK_TEXT: _p::ty::ConstPtr<_p::Text> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([1u8, 0u8, 0u8, 0u8, 250u8, 2u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 32u8, 98u8, 97u8, 114u8, 32u8]), + _p::Word([98u8, 97u8, 122u8, 10u8, 34u8, 113u8, 117u8, 120u8]), + _p::Word([34u8, 32u8, 96u8, 99u8, 111u8, 114u8, 103u8, 101u8]), + _p::Word([96u8, 32u8, 39u8, 103u8, 114u8, 97u8, 117u8, 108u8]), + _p::Word([116u8, 39u8, 10u8, 114u8, 101u8, 103u8, 117u8, 108u8]), + _p::Word([97u8, 114u8, 34u8, 113u8, 117u8, 111u8, 116u8, 101u8]), + _p::Word([100u8, 34u8, 108u8, 105u8, 110u8, 101u8, 103u8, 97u8]), + _p::Word([114u8, 112u8, 108u8, 121u8, 92u8, 110u8, 119u8, 97u8]), + _p::Word([108u8, 100u8, 111u8, 92u8, 116u8, 102u8, 114u8, 101u8]), + _p::Word([100u8, 92u8, 34u8, 112u8, 108u8, 117u8, 103u8, 104u8]), + _p::Word([92u8, 34u8, 120u8, 121u8, 122u8, 122u8, 121u8, 92u8]), + _p::Word([39u8, 116u8, 104u8, 117u8, 100u8, 10u8, 0u8, 0u8]), + ], + ) +}; +#[derive(Clone)] +pub struct TestAnyPointerConstants(T); +impl _p::IntoFamily for TestAnyPointerConstants { + type Family = TestAnyPointerConstants; +} +impl _p::Capable for TestAnyPointerConstants { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestAnyPointerConstants>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestAnyPointerConstants(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_any_pointer_constants::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_any_pointer_constants::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestAnyPointerConstants(ptr) + } +} +impl< + 'a, + T: _p::rpc::Table, +> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_any_pointer_constants::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_any_pointer_constants::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_any_pointer_constants::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_any_pointer_constants::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl< + 'a, + T: _p::rpc::Table, +> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_any_pointer_constants::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_any_pointer_constants::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_any_pointer_constants::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_any_pointer_constants::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestAnyPointerConstants { + type Reader<'a, T: _p::rpc::Table> = test_any_pointer_constants::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_any_pointer_constants::Builder<'a, T>; +} +impl _p::ty::Struct for TestAnyPointerConstants { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 4u16, + }; +} +impl TestAnyPointerConstants { + const ANY_KIND_AS_STRUCT: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const ANY_STRUCT_AS_STRUCT: _p::Descriptor<_p::AnyStruct> = _p::Descriptor::< + _p::AnyStruct, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; + const ANY_KIND_AS_LIST: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 2u32, + default: ::core::option::Option::None, + }; + const ANY_LIST_AS_LIST: _p::Descriptor<_p::AnyList> = _p::Descriptor::<_p::AnyList> { + slot: 3u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_any_pointer_constants::Reader<'p, T> { + #[inline] + pub fn any_kind_as_struct(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &TestAnyPointerConstants::ANY_KIND_AS_STRUCT, + ) + } + } + #[inline] + pub fn any_struct_as_struct(&self) -> _p::Accessor<'_, 'p, T, _p::AnyStruct> { + unsafe { + <_p::AnyStruct as _p::field::FieldType>::accessor( + &self.0, + &TestAnyPointerConstants::ANY_STRUCT_AS_STRUCT, + ) + } + } + #[inline] + pub fn any_kind_as_list(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &TestAnyPointerConstants::ANY_KIND_AS_LIST, + ) + } + } + #[inline] + pub fn any_list_as_list(&self) -> _p::Accessor<'_, 'p, T, _p::AnyList> { + unsafe { + <_p::AnyList as _p::field::FieldType>::accessor( + &self.0, + &TestAnyPointerConstants::ANY_LIST_AS_LIST, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_any_pointer_constants::Builder<'p, T> { + #[inline] + pub fn any_kind_as_struct(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &TestAnyPointerConstants::ANY_KIND_AS_STRUCT, + ) + } + } + #[inline] + pub fn any_struct_as_struct(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyStruct> { + unsafe { + <_p::AnyStruct as _p::field::FieldType>::accessor( + &mut self.0, + &TestAnyPointerConstants::ANY_STRUCT_AS_STRUCT, + ) + } + } + #[inline] + pub fn any_kind_as_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &TestAnyPointerConstants::ANY_KIND_AS_LIST, + ) + } + } + #[inline] + pub fn any_list_as_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyList> { + unsafe { + <_p::AnyList as _p::field::FieldType>::accessor( + &mut self.0, + &TestAnyPointerConstants::ANY_LIST_AS_LIST, + ) + } + } + #[inline] + pub fn into_any_kind_as_struct(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &TestAnyPointerConstants::ANY_KIND_AS_STRUCT, + ) + } + } + #[inline] + pub fn into_any_struct_as_struct(self) -> _p::AccessorOwned<'p, T, _p::AnyStruct> { + unsafe { + <_p::AnyStruct as _p::field::FieldType>::accessor( + self.0, + &TestAnyPointerConstants::ANY_STRUCT_AS_STRUCT, + ) + } + } + #[inline] + pub fn into_any_kind_as_list(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &TestAnyPointerConstants::ANY_KIND_AS_LIST, + ) + } + } + #[inline] + pub fn into_any_list_as_list(self) -> _p::AccessorOwned<'p, T, _p::AnyList> { + unsafe { + <_p::AnyList as _p::field::FieldType>::accessor( + self.0, + &TestAnyPointerConstants::ANY_LIST_AS_LIST, + ) + } + } +} +pub mod test_any_pointer_constants { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestAnyPointerConstants< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestAnyPointerConstants< + _p::StructBuilder<'a, T>, + >; +} +pub const ANY_POINTER_CONSTANTS: _p::ty::ConstPtr<_p::Struct> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 4u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([68u8, 3u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([125u8, 6u8, 0u8, 0u8, 20u8, 0u8, 0u8, 0u8]), + _p::Word([125u8, 6u8, 0u8, 0u8, 20u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 244u8, 128u8, 13u8, 14u8, 16u8, 76u8, 251u8]), + _p::Word([78u8, 115u8, 232u8, 56u8, 166u8, 51u8, 0u8, 0u8]), + _p::Word([90u8, 0u8, 210u8, 4u8, 20u8, 136u8, 98u8, 3u8]), + _p::Word([210u8, 10u8, 111u8, 18u8, 33u8, 25u8, 204u8, 4u8]), + _p::Word([95u8, 112u8, 9u8, 175u8, 2u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 144u8, 117u8, 64u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 26u8, 0u8, 0u8, 0u8]), + _p::Word([76u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 24u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 41u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([37u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([53u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([65u8, 1u8, 0u8, 0u8, 52u8, 0u8, 0u8, 0u8]), + _p::Word([73u8, 1u8, 0u8, 0u8, 53u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 1u8, 0u8, 0u8, 119u8, 2u8, 0u8, 0u8]), + _p::Word([213u8, 2u8, 0u8, 0u8, 27u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 122u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([72u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([110u8, 101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 114u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([114u8, 101u8, 97u8, 108u8, 108u8, 121u8, 32u8, 110u8]), + _p::Word([101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8, 0u8]), + _p::Word([26u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 222u8, 128u8, 127u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 210u8, 233u8, 0u8, 128u8, 255u8, 127u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 64u8, 211u8, 160u8, 250u8]), + _p::Word([0u8, 0u8, 0u8, 128u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([46u8, 117u8, 19u8, 253u8, 138u8, 150u8, 253u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 128u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([12u8, 34u8, 0u8, 255u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 46u8, 22u8, 0u8, 0u8, 255u8, 255u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 192u8, 44u8, 95u8, 5u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([210u8, 138u8, 236u8, 2u8, 117u8, 105u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 56u8, 180u8, 150u8, 73u8]), + _p::Word([194u8, 189u8, 240u8, 124u8, 194u8, 189u8, 240u8, 252u8]), + _p::Word([234u8, 28u8, 8u8, 2u8, 234u8, 28u8, 8u8, 130u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([64u8, 222u8, 119u8, 131u8, 33u8, 18u8, 220u8, 66u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 127u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 255u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 0u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 128u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([99u8, 111u8, 114u8, 103u8, 101u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 114u8, 97u8, 117u8, 108u8, 116u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 97u8, 114u8, 112u8, 108u8, 121u8, 0u8, 0u8]), + _p::Word([119u8, 97u8, 108u8, 100u8, 111u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 114u8, 101u8, 100u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 49u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 50u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 51u8, 0u8, 0u8]), + _p::Word([3u8, 0u8, 1u8, 0u8, 6u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 244u8, 128u8, 13u8, 14u8, 16u8, 76u8, 251u8]), + _p::Word([78u8, 115u8, 232u8, 56u8, 166u8, 51u8, 0u8, 0u8]), + _p::Word([90u8, 0u8, 210u8, 4u8, 20u8, 136u8, 98u8, 3u8]), + _p::Word([210u8, 10u8, 111u8, 18u8, 33u8, 25u8, 204u8, 4u8]), + _p::Word([95u8, 112u8, 9u8, 175u8, 2u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 144u8, 117u8, 64u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 26u8, 0u8, 0u8, 0u8]), + _p::Word([76u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 24u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 41u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([33u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([37u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 35u8, 0u8, 0u8, 0u8]), + _p::Word([49u8, 1u8, 0u8, 0u8, 36u8, 0u8, 0u8, 0u8]), + _p::Word([53u8, 1u8, 0u8, 0u8, 37u8, 0u8, 0u8, 0u8]), + _p::Word([65u8, 1u8, 0u8, 0u8, 52u8, 0u8, 0u8, 0u8]), + _p::Word([73u8, 1u8, 0u8, 0u8, 53u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 1u8, 0u8, 0u8, 30u8, 0u8, 0u8, 0u8]), + _p::Word([133u8, 1u8, 0u8, 0u8, 119u8, 2u8, 0u8, 0u8]), + _p::Word([213u8, 2u8, 0u8, 0u8, 27u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 122u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([72u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([110u8, 101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([77u8, 0u8, 0u8, 0u8, 114u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([114u8, 101u8, 97u8, 108u8, 108u8, 121u8, 32u8, 110u8]), + _p::Word([101u8, 115u8, 116u8, 101u8, 100u8, 0u8, 0u8, 0u8]), + _p::Word([26u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 222u8, 128u8, 127u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 210u8, 233u8, 0u8, 128u8, 255u8, 127u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 64u8, 211u8, 160u8, 250u8]), + _p::Word([0u8, 0u8, 0u8, 128u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([46u8, 117u8, 19u8, 253u8, 138u8, 150u8, 253u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 128u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 127u8]), + _p::Word([12u8, 34u8, 0u8, 255u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([210u8, 4u8, 46u8, 22u8, 0u8, 0u8, 255u8, 255u8]), + _p::Word([78u8, 97u8, 188u8, 0u8, 192u8, 44u8, 95u8, 5u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([121u8, 223u8, 13u8, 134u8, 72u8, 112u8, 0u8, 0u8]), + _p::Word([210u8, 138u8, 236u8, 2u8, 117u8, 105u8, 2u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 56u8, 180u8, 150u8, 73u8]), + _p::Word([194u8, 189u8, 240u8, 124u8, 194u8, 189u8, 240u8, 252u8]), + _p::Word([234u8, 28u8, 8u8, 2u8, 234u8, 28u8, 8u8, 130u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([64u8, 222u8, 119u8, 131u8, 33u8, 18u8, 220u8, 66u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 127u8]), + _p::Word([41u8, 144u8, 35u8, 202u8, 229u8, 200u8, 118u8, 255u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 0u8]), + _p::Word([145u8, 247u8, 80u8, 55u8, 158u8, 120u8, 102u8, 128u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 58u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([99u8, 111u8, 114u8, 103u8, 101u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 114u8, 97u8, 117u8, 108u8, 116u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 50u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([103u8, 97u8, 114u8, 112u8, 108u8, 121u8, 0u8, 0u8]), + _p::Word([119u8, 97u8, 108u8, 100u8, 111u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 114u8, 101u8, 100u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([12u8, 0u8, 0u8, 0u8, 6u8, 0u8, 20u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([29u8, 1u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([189u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([93u8, 0u8, 0u8, 0u8, 122u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 49u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 50u8, 0u8, 0u8]), + _p::Word([120u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8]), + _p::Word([108u8, 105u8, 115u8, 116u8, 32u8, 51u8, 0u8, 0u8]), + _p::Word([3u8, 0u8, 1u8, 0u8, 6u8, 0u8, 0u8, 0u8]), + _p::Word([199u8, 107u8, 159u8, 6u8, 57u8, 148u8, 96u8, 249u8]), + _p::Word([199u8, 107u8, 159u8, 6u8, 57u8, 148u8, 96u8, 249u8]), + ], + ) +}; +#[derive(Clone)] +pub struct TestListOfAny(T); +impl _p::IntoFamily for TestListOfAny { + type Family = TestListOfAny; +} +impl _p::Capable for TestListOfAny { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestListOfAny>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestListOfAny(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_list_of_any::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_list_of_any::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestListOfAny(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_list_of_any::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_list_of_any::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_list_of_any::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_list_of_any::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_list_of_any::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_list_of_any::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_list_of_any::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_list_of_any::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestListOfAny { + type Reader<'a, T: _p::rpc::Table> = test_list_of_any::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_list_of_any::Builder<'a, T>; +} +impl _p::ty::Struct for TestListOfAny { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 2u16, + }; +} +impl TestListOfAny { + const CAP_LIST: _p::Descriptor<_p::List<_p::AnyPtr>> = _p::Descriptor::< + _p::List<_p::AnyPtr>, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; + const LIST_LIST: _p::Descriptor<_p::List<_p::AnyList>> = _p::Descriptor::< + _p::List<_p::AnyList>, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_list_of_any::Reader<'p, T> { + #[inline] + pub fn cap_list(&self) -> _p::Accessor<'_, 'p, T, _p::List<_p::AnyPtr>> { + unsafe { + <_p::List< + _p::AnyPtr, + > as _p::field::FieldType>::accessor(&self.0, &TestListOfAny::CAP_LIST) + } + } + #[inline] + pub fn list_list(&self) -> _p::Accessor<'_, 'p, T, _p::List<_p::AnyList>> { + unsafe { + <_p::List< + _p::AnyList, + > as _p::field::FieldType>::accessor(&self.0, &TestListOfAny::LIST_LIST) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_list_of_any::Builder<'p, T> { + #[inline] + pub fn cap_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::AnyPtr>> { + unsafe { + <_p::List< + _p::AnyPtr, + > as _p::field::FieldType>::accessor(&mut self.0, &TestListOfAny::CAP_LIST) + } + } + #[inline] + pub fn list_list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::AnyList>> { + unsafe { + <_p::List< + _p::AnyList, + > as _p::field::FieldType>::accessor(&mut self.0, &TestListOfAny::LIST_LIST) + } + } + #[inline] + pub fn into_cap_list(self) -> _p::AccessorOwned<'p, T, _p::List<_p::AnyPtr>> { + unsafe { + <_p::List< + _p::AnyPtr, + > as _p::field::FieldType>::accessor(self.0, &TestListOfAny::CAP_LIST) + } + } + #[inline] + pub fn into_list_list(self) -> _p::AccessorOwned<'p, T, _p::List<_p::AnyList>> { + unsafe { + <_p::List< + _p::AnyList, + > as _p::field::FieldType>::accessor(self.0, &TestListOfAny::LIST_LIST) + } + } +} +pub mod test_list_of_any { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestListOfAny< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestListOfAny< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestContainMembrane(T); +impl _p::IntoFamily for TestContainMembrane { + type Family = TestContainMembrane; +} +impl _p::Capable for TestContainMembrane { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestContainMembrane>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestContainMembrane(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_contain_membrane::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_contain_membrane::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestContainMembrane(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_contain_membrane::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_contain_membrane::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_contain_membrane::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_contain_membrane::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_contain_membrane::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_contain_membrane::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_contain_membrane::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_contain_membrane::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestContainMembrane { + type Reader<'a, T: _p::rpc::Table> = test_contain_membrane::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_contain_membrane::Builder<'a, T>; +} +impl _p::ty::Struct for TestContainMembrane { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 2u16, + }; +} +impl TestContainMembrane { + const CAP: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const LIST: _p::Descriptor<_p::List<_p::AnyPtr>> = _p::Descriptor::< + _p::List<_p::AnyPtr>, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_contain_membrane::Reader<'p, T> { + #[inline] + pub fn cap(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &TestContainMembrane::CAP, + ) + } + } + #[inline] + pub fn list(&self) -> _p::Accessor<'_, 'p, T, _p::List<_p::AnyPtr>> { + unsafe { + <_p::List< + _p::AnyPtr, + > as _p::field::FieldType>::accessor(&self.0, &TestContainMembrane::LIST) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_contain_membrane::Builder<'p, T> { + #[inline] + pub fn cap(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &TestContainMembrane::CAP, + ) + } + } + #[inline] + pub fn list(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::AnyPtr>> { + unsafe { + <_p::List< + _p::AnyPtr, + > as _p::field::FieldType>::accessor(&mut self.0, &TestContainMembrane::LIST) + } + } + #[inline] + pub fn into_cap(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &TestContainMembrane::CAP, + ) + } + } + #[inline] + pub fn into_list(self) -> _p::AccessorOwned<'p, T, _p::List<_p::AnyPtr>> { + unsafe { + <_p::List< + _p::AnyPtr, + > as _p::field::FieldType>::accessor(self.0, &TestContainMembrane::LIST) + } + } +} +pub mod test_contain_membrane { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestContainMembrane< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestContainMembrane< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestTransferCap(T); +impl _p::IntoFamily for TestTransferCap { + type Family = TestTransferCap; +} +impl _p::Capable for TestTransferCap { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestTransferCap>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestTransferCap(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_transfer_cap::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_transfer_cap::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestTransferCap(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_transfer_cap::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_transfer_cap::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_transfer_cap::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_transfer_cap::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_transfer_cap::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_transfer_cap::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_transfer_cap::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_transfer_cap::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestTransferCap { + type Reader<'a, T: _p::rpc::Table> = test_transfer_cap::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_transfer_cap::Builder<'a, T>; +} +impl _p::ty::Struct for TestTransferCap { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; +} +impl TestTransferCap { + const LIST: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_transfer_cap::Reader<'p, T> { + #[inline] + pub fn list( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestTransferCap::LIST) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_transfer_cap::Builder<'p, T> { + #[inline] + pub fn list( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestTransferCap::LIST) + } + } + #[inline] + pub fn into_list( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestTransferCap::LIST) + } + } +} +pub mod test_transfer_cap { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestTransferCap< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestTransferCap< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct Element(T); + impl _p::IntoFamily for Element { + type Family = Element; + } + impl _p::Capable for Element { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = Element>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (Element(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for element::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for element::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + Element(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: element::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for element::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for element::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for element::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: element::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for element::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for element::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for element::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for Element { + type Reader<'a, T: _p::rpc::Table> = element::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = element::Builder<'a, T>; + } + impl _p::ty::Struct for Element { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 2u16, + }; + } + impl Element { + const TEXT: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const CAP: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 1u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> element::Reader<'p, T> { + #[inline] + pub fn text(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &Element::TEXT) + } + } + #[inline] + pub fn cap(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(&self.0, &Element::CAP) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> element::Builder<'p, T> { + #[inline] + pub fn text(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &Element::TEXT) + } + } + #[inline] + pub fn cap(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &Element::CAP, + ) + } + } + #[inline] + pub fn into_text(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &Element::TEXT) + } + } + #[inline] + pub fn into_cap(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor(self.0, &Element::CAP) + } + } + } + pub mod element { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::Element< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::Element< + _p::StructBuilder<'a, T>, + >; + } +} +#[derive(Clone)] +pub struct TestSturdyRef(T); +impl _p::IntoFamily for TestSturdyRef { + type Family = TestSturdyRef; +} +impl _p::Capable for TestSturdyRef { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestSturdyRef>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestSturdyRef(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_sturdy_ref::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_sturdy_ref::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestSturdyRef(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_sturdy_ref::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_sturdy_ref::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_sturdy_ref::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_sturdy_ref::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_sturdy_ref::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_sturdy_ref::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_sturdy_ref::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_sturdy_ref::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestSturdyRef { + type Reader<'a, T: _p::rpc::Table> = test_sturdy_ref::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_sturdy_ref::Builder<'a, T>; +} +impl _p::ty::Struct for TestSturdyRef { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 2u16, + }; +} +impl TestSturdyRef { + const HOST_ID: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; + const OBJECT_ID: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 1u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_sturdy_ref::Reader<'p, T> { + #[inline] + pub fn host_id(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestSturdyRefHostId, + > as _p::field::FieldType>::accessor(&self.0, &TestSturdyRef::HOST_ID) + } + } + #[inline] + pub fn object_id(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &TestSturdyRef::OBJECT_ID, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_sturdy_ref::Builder<'p, T> { + #[inline] + pub fn host_id( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestSturdyRefHostId, + > as _p::field::FieldType>::accessor(&mut self.0, &TestSturdyRef::HOST_ID) + } + } + #[inline] + pub fn object_id(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &TestSturdyRef::OBJECT_ID, + ) + } + } + #[inline] + pub fn into_host_id( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestSturdyRefHostId, + > as _p::field::FieldType>::accessor(self.0, &TestSturdyRef::HOST_ID) + } + } + #[inline] + pub fn into_object_id(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &TestSturdyRef::OBJECT_ID, + ) + } + } +} +pub mod test_sturdy_ref { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestSturdyRef< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestSturdyRef< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestSturdyRefHostId(T); +impl _p::IntoFamily for TestSturdyRefHostId { + type Family = TestSturdyRefHostId; +} +impl _p::Capable for TestSturdyRefHostId { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestSturdyRefHostId>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestSturdyRefHostId(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_sturdy_ref_host_id::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_sturdy_ref_host_id::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestSturdyRefHostId(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_sturdy_ref_host_id::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_sturdy_ref_host_id::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_sturdy_ref_host_id::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_sturdy_ref_host_id::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_sturdy_ref_host_id::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_sturdy_ref_host_id::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_sturdy_ref_host_id::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_sturdy_ref_host_id::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestSturdyRefHostId { + type Reader<'a, T: _p::rpc::Table> = test_sturdy_ref_host_id::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_sturdy_ref_host_id::Builder<'a, T>; +} +impl _p::ty::Struct for TestSturdyRefHostId { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; +} +impl TestSturdyRefHostId { + const HOST: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_sturdy_ref_host_id::Reader<'p, T> { + #[inline] + pub fn host(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &self.0, + &TestSturdyRefHostId::HOST, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_sturdy_ref_host_id::Builder<'p, T> { + #[inline] + pub fn host(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TestSturdyRefHostId::HOST, + ) + } + } + #[inline] + pub fn into_host(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + self.0, + &TestSturdyRefHostId::HOST, + ) + } + } +} +pub mod test_sturdy_ref_host_id { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestSturdyRefHostId< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestSturdyRefHostId< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestSturdyRefObjectId(T); +impl _p::IntoFamily for TestSturdyRefObjectId { + type Family = TestSturdyRefObjectId; +} +impl _p::Capable for TestSturdyRefObjectId { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestSturdyRefObjectId>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestSturdyRefObjectId(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_sturdy_ref_object_id::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_sturdy_ref_object_id::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestSturdyRefObjectId(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_sturdy_ref_object_id::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_sturdy_ref_object_id::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_sturdy_ref_object_id::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_sturdy_ref_object_id::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl< + 'a, + T: _p::rpc::Table, +> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_sturdy_ref_object_id::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_sturdy_ref_object_id::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_sturdy_ref_object_id::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_sturdy_ref_object_id::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestSturdyRefObjectId { + type Reader<'a, T: _p::rpc::Table> = test_sturdy_ref_object_id::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_sturdy_ref_object_id::Builder<'a, T>; +} +impl _p::ty::Struct for TestSturdyRefObjectId { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 0u16, + }; +} +impl TestSturdyRefObjectId { + const TAG: _p::Descriptor<_p::Enum> = _p::Descriptor::< + _p::Enum, + > { + slot: 0u32, + default: test_sturdy_ref_object_id::Tag::TestInterface, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_sturdy_ref_object_id::Reader<'p, T> { + #[inline] + pub fn tag( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + test_sturdy_ref_object_id::Tag, + > as _p::field::FieldType>::accessor(&self.0, &TestSturdyRefObjectId::TAG) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_sturdy_ref_object_id::Builder<'p, T> { + #[inline] + pub fn tag( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + test_sturdy_ref_object_id::Tag, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestSturdyRefObjectId::TAG, + ) + } + } +} +pub mod test_sturdy_ref_object_id { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestSturdyRefObjectId< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestSturdyRefObjectId< + _p::StructBuilder<'a, T>, + >; + #[repr(u16)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)] + pub enum Tag { + #[default] + TestInterface, + TestExtends, + TestPipeline, + TestTailCallee, + TestTailCaller, + TestMoreStuff, + } + impl core::convert::TryFrom for Tag { + type Error = _p::NotInSchema; + #[inline] + fn try_from(value: u16) -> Result { + match value { + 0u16 => Ok(Self::TestInterface), + 1u16 => Ok(Self::TestExtends), + 2u16 => Ok(Self::TestPipeline), + 3u16 => Ok(Self::TestTailCallee), + 4u16 => Ok(Self::TestTailCaller), + 5u16 => Ok(Self::TestMoreStuff), + value => Err(_p::NotInSchema(value)), + } + } + } + impl core::convert::From for u16 { + #[inline] + fn from(value: Tag) -> Self { + value as u16 + } + } + impl _p::ty::Enum for Tag {} +} +#[derive(Clone)] +pub struct TestProvisionId(T); +impl _p::IntoFamily for TestProvisionId { + type Family = TestProvisionId; +} +impl _p::Capable for TestProvisionId { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestProvisionId>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestProvisionId(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_provision_id::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_provision_id::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestProvisionId(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_provision_id::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_provision_id::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_provision_id::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_provision_id::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_provision_id::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_provision_id::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_provision_id::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_provision_id::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestProvisionId { + type Reader<'a, T: _p::rpc::Table> = test_provision_id::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_provision_id::Builder<'a, T>; +} +impl _p::ty::Struct for TestProvisionId { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 0u16, + }; +} +impl TestProvisionId {} +impl<'p, T: _p::rpc::Table + 'p> test_provision_id::Reader<'p, T> {} +impl<'p, T: _p::rpc::Table + 'p> test_provision_id::Builder<'p, T> {} +pub mod test_provision_id { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestProvisionId< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestProvisionId< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestRecipientId(T); +impl _p::IntoFamily for TestRecipientId { + type Family = TestRecipientId; +} +impl _p::Capable for TestRecipientId { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestRecipientId>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestRecipientId(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_recipient_id::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_recipient_id::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestRecipientId(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_recipient_id::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_recipient_id::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_recipient_id::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_recipient_id::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_recipient_id::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_recipient_id::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_recipient_id::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_recipient_id::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestRecipientId { + type Reader<'a, T: _p::rpc::Table> = test_recipient_id::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_recipient_id::Builder<'a, T>; +} +impl _p::ty::Struct for TestRecipientId { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 0u16, + }; +} +impl TestRecipientId {} +impl<'p, T: _p::rpc::Table + 'p> test_recipient_id::Reader<'p, T> {} +impl<'p, T: _p::rpc::Table + 'p> test_recipient_id::Builder<'p, T> {} +pub mod test_recipient_id { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestRecipientId< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestRecipientId< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestThirdPartyCapId(T); +impl _p::IntoFamily for TestThirdPartyCapId { + type Family = TestThirdPartyCapId; +} +impl _p::Capable for TestThirdPartyCapId { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestThirdPartyCapId>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestThirdPartyCapId(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_third_party_cap_id::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_third_party_cap_id::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestThirdPartyCapId(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_third_party_cap_id::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_third_party_cap_id::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_third_party_cap_id::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_third_party_cap_id::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_third_party_cap_id::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_third_party_cap_id::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_third_party_cap_id::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_third_party_cap_id::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestThirdPartyCapId { + type Reader<'a, T: _p::rpc::Table> = test_third_party_cap_id::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_third_party_cap_id::Builder<'a, T>; +} +impl _p::ty::Struct for TestThirdPartyCapId { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 0u16, + }; +} +impl TestThirdPartyCapId {} +impl<'p, T: _p::rpc::Table + 'p> test_third_party_cap_id::Reader<'p, T> {} +impl<'p, T: _p::rpc::Table + 'p> test_third_party_cap_id::Builder<'p, T> {} +pub mod test_third_party_cap_id { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestThirdPartyCapId< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestThirdPartyCapId< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestJoinResult(T); +impl _p::IntoFamily for TestJoinResult { + type Family = TestJoinResult; +} +impl _p::Capable for TestJoinResult { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestJoinResult>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestJoinResult(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_join_result::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_join_result::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestJoinResult(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_join_result::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_join_result::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader for test_join_result::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_join_result::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_join_result::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_join_result::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_join_result::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for test_join_result::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestJoinResult { + type Reader<'a, T: _p::rpc::Table> = test_join_result::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_join_result::Builder<'a, T>; +} +impl _p::ty::Struct for TestJoinResult { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 0u16, + }; +} +impl TestJoinResult {} +impl<'p, T: _p::rpc::Table + 'p> test_join_result::Reader<'p, T> {} +impl<'p, T: _p::rpc::Table + 'p> test_join_result::Builder<'p, T> {} +pub mod test_join_result { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestJoinResult< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestJoinResult< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestNameAnnotation(T); +impl _p::IntoFamily for TestNameAnnotation { + type Family = TestNameAnnotation; +} +impl _p::Capable for TestNameAnnotation { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestNameAnnotation>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestNameAnnotation(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_name_annotation::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_name_annotation::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestNameAnnotation(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_name_annotation::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_name_annotation::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_name_annotation::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_name_annotation::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_name_annotation::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_name_annotation::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_name_annotation::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_name_annotation::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestNameAnnotation { + type Reader<'a, T: _p::rpc::Table> = test_name_annotation::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_name_annotation::Builder<'a, T>; +} +impl _p::ty::Struct for TestNameAnnotation { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; +} +impl TestNameAnnotation { + const ANOTHER_BAD_FIELD_NAME: _p::Descriptor< + _p::Enum, + > = _p::Descriptor::<_p::Enum> { + slot: 2u32, + default: test_name_annotation::BadlyNamedEnum::Foo, + }; + const BADLY_NAMED_UNION: _p::Descriptor< + _p::Group, + > = (); + const BAD_FIELD_NAME: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 0u16, + }, + field: _p::Descriptor:: { + slot: 0u32, + default: false, + }, + }; + const BAR: _p::VariantDescriptor = _p::VariantDescriptor:: { + variant: _p::VariantInfo { + slot: 1u32, + case: 1u16, + }, + field: _p::Descriptor:: { + slot: 0u32, + default: 0i8, + }, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_name_annotation::Reader<'p, T> { + #[inline] + pub fn another_bad_field_name( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + test_name_annotation::BadlyNamedEnum, + > as _p::field::FieldType>::accessor( + &self.0, + &TestNameAnnotation::ANOTHER_BAD_FIELD_NAME, + ) + } + } + #[inline] + pub fn badly_named_union( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_name_annotation::BadlyNamedUnion, + > as _p::field::FieldType>::accessor( + &self.0, + &TestNameAnnotation::BADLY_NAMED_UNION, + ) + } + } + #[inline] + pub fn bad_field_name(&self) -> _p::Variant<'_, 'p, T, bool> { + unsafe { + ::variant( + &self.0, + &TestNameAnnotation::BAD_FIELD_NAME, + ) + } + } + #[inline] + pub fn bar(&self) -> _p::Variant<'_, 'p, T, i8> { + unsafe { + ::variant(&self.0, &TestNameAnnotation::BAR) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_name_annotation::Builder<'p, T> { + #[inline] + pub fn another_bad_field_name( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Enum> { + unsafe { + <_p::Enum< + test_name_annotation::BadlyNamedEnum, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestNameAnnotation::ANOTHER_BAD_FIELD_NAME, + ) + } + } + #[inline] + pub fn badly_named_union( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_name_annotation::BadlyNamedUnion, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestNameAnnotation::BADLY_NAMED_UNION, + ) + } + } + #[inline] + pub fn bad_field_name(&mut self) -> _p::VariantMut<'_, 'p, T, bool> { + unsafe { + ::variant( + &mut self.0, + &TestNameAnnotation::BAD_FIELD_NAME, + ) + } + } + #[inline] + pub fn bar(&mut self) -> _p::VariantMut<'_, 'p, T, i8> { + unsafe { + ::variant(&mut self.0, &TestNameAnnotation::BAR) + } + } + #[inline] + pub fn into_badly_named_union( + self, + ) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_name_annotation::BadlyNamedUnion, + > as _p::field::FieldType>::accessor( + self.0, + &TestNameAnnotation::BADLY_NAMED_UNION, + ) + } + } + #[inline] + pub fn which( + &mut self, + ) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } +} +pub mod test_name_annotation { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestNameAnnotation< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestNameAnnotation< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + BadFieldName(_p::ViewOf), + Bar(_p::ViewOf), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get(repr: &'b Reader<'p, T>) -> Result { + let tag = repr.0.data_field::(1usize); + match tag { + 0u16 => { + Ok( + Which::BadFieldName( + ::accessor( + &repr.0, + &super::TestNameAnnotation::BAD_FIELD_NAME.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Bar( + ::accessor( + &repr.0, + &super::TestNameAnnotation::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(1usize); + match tag { + 0u16 => { + Ok( + Which::BadFieldName( + ::accessor( + &mut repr.0, + &super::TestNameAnnotation::BAD_FIELD_NAME.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Bar( + ::accessor( + &mut repr.0, + &super::TestNameAnnotation::BAR.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + #[repr(u16)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)] + pub enum BadlyNamedEnum { + #[default] + Foo, + Bar, + Baz, + } + impl core::convert::TryFrom for BadlyNamedEnum { + type Error = _p::NotInSchema; + #[inline] + fn try_from(value: u16) -> Result { + match value { + 0u16 => Ok(Self::Foo), + 1u16 => Ok(Self::Bar), + 2u16 => Ok(Self::Baz), + value => Err(_p::NotInSchema(value)), + } + } + } + impl core::convert::From for u16 { + #[inline] + fn from(value: BadlyNamedEnum) -> Self { + value as u16 + } + } + impl _p::ty::Enum for BadlyNamedEnum {} + #[derive(Clone)] + pub struct NestedStruct(T); + impl _p::IntoFamily for NestedStruct { + type Family = NestedStruct; + } + impl _p::Capable for NestedStruct { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = NestedStruct>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (NestedStruct(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for nested_struct::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for nested_struct::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + NestedStruct(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: nested_struct::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for nested_struct::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for nested_struct::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for nested_struct::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: nested_struct::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for nested_struct::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for nested_struct::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for nested_struct::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for NestedStruct { + type Reader<'a, T: _p::rpc::Table> = nested_struct::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = nested_struct::Builder<'a, T>; + } + impl _p::ty::Struct for NestedStruct { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; + } + impl NestedStruct { + const BAD_NESTED_FIELD_NAME: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: false, + }; + const ANOTHER_BAD_NESTED_FIELD_NAME: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; + } + impl<'p, T: _p::rpc::Table + 'p> nested_struct::Reader<'p, T> { + #[inline] + pub fn bad_nested_field_name(&self) -> _p::Accessor<'_, 'p, T, bool> { + unsafe { + ::accessor( + &self.0, + &NestedStruct::BAD_NESTED_FIELD_NAME, + ) + } + } + #[inline] + pub fn another_bad_nested_field_name( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + NestedStruct, + > as _p::field::FieldType>::accessor( + &self.0, + &NestedStruct::ANOTHER_BAD_NESTED_FIELD_NAME, + ) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> nested_struct::Builder<'p, T> { + #[inline] + pub fn bad_nested_field_name(&mut self) -> _p::AccessorMut<'_, 'p, T, bool> { + unsafe { + ::accessor( + &mut self.0, + &NestedStruct::BAD_NESTED_FIELD_NAME, + ) + } + } + #[inline] + pub fn another_bad_nested_field_name( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + NestedStruct, + > as _p::field::FieldType>::accessor( + &mut self.0, + &NestedStruct::ANOTHER_BAD_NESTED_FIELD_NAME, + ) + } + } + #[inline] + pub fn into_another_bad_nested_field_name( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + NestedStruct, + > as _p::field::FieldType>::accessor( + self.0, + &NestedStruct::ANOTHER_BAD_NESTED_FIELD_NAME, + ) + } + } + } + pub mod nested_struct { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::NestedStruct< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::NestedStruct< + _p::StructBuilder<'a, T>, + >; + #[repr(u16)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)] + pub enum DeeplyNestedEnum { + #[default] + Quux, + Corge, + Grault, + } + impl core::convert::TryFrom for DeeplyNestedEnum { + type Error = _p::NotInSchema; + #[inline] + fn try_from(value: u16) -> Result { + match value { + 0u16 => Ok(Self::Quux), + 1u16 => Ok(Self::Corge), + 2u16 => Ok(Self::Grault), + value => Err(_p::NotInSchema(value)), + } + } + } + impl core::convert::From for u16 { + #[inline] + fn from(value: DeeplyNestedEnum) -> Self { + value as u16 + } + } + impl _p::ty::Enum for DeeplyNestedEnum {} + } + #[derive(Clone)] + pub struct BadlyNamedUnion(T); + impl _p::IntoFamily for BadlyNamedUnion { + type Family = BadlyNamedUnion; + } + impl _p::Capable for BadlyNamedUnion { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = BadlyNamedUnion>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (BadlyNamedUnion(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for badly_named_union::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for badly_named_union::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + BadlyNamedUnion(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: badly_named_union::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for badly_named_union::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader + for badly_named_union::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for badly_named_union::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: badly_named_union::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for badly_named_union::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for badly_named_union::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder + for badly_named_union::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for BadlyNamedUnion { + type Reader<'a, T: _p::rpc::Table> = badly_named_union::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = badly_named_union::Builder<'a, T>; + } + impl _p::FieldGroup for BadlyNamedUnion { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + s.set_field_unchecked(3usize, 0); + <_p::Group< + badly_named_union::BadlyNamedGroup, + > as _p::field::FieldType>::clear( + s, + &BadlyNamedUnion::BADLY_NAMED_GROUP.field, + ); + } + } + impl BadlyNamedUnion { + const BADLY_NAMED_GROUP: _p::VariantDescriptor< + _p::Group, + > = _p::VariantDescriptor::<_p::Group> { + variant: _p::VariantInfo { + slot: 3u32, + case: 0u16, + }, + field: (), + }; + const BAZ: _p::VariantDescriptor<_p::Struct> = _p::VariantDescriptor::< + _p::Struct, + > { + variant: _p::VariantInfo { + slot: 3u32, + case: 1u16, + }, + field: _p::Descriptor::<_p::Struct> { + slot: 0u32, + default: ::core::option::Option::None, + }, + }; + } + impl<'p, T: _p::rpc::Table + 'p> badly_named_union::Reader<'p, T> { + #[inline] + pub fn badly_named_group( + &self, + ) -> _p::Variant<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + badly_named_union::BadlyNamedGroup, + > as _p::field::FieldType>::variant( + &self.0, + &BadlyNamedUnion::BADLY_NAMED_GROUP, + ) + } + } + #[inline] + pub fn baz(&self) -> _p::Variant<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + NestedStruct, + > as _p::field::FieldType>::variant(&self.0, &BadlyNamedUnion::BAZ) + } + } + #[inline] + pub fn which(&self) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + impl<'p, T: _p::rpc::Table + 'p> badly_named_union::Builder<'p, T> { + #[inline] + pub fn badly_named_group( + &mut self, + ) -> _p::VariantMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + badly_named_union::BadlyNamedGroup, + > as _p::field::FieldType>::variant( + &mut self.0, + &BadlyNamedUnion::BADLY_NAMED_GROUP, + ) + } + } + #[inline] + pub fn baz(&mut self) -> _p::VariantMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + NestedStruct, + > as _p::field::FieldType>::variant(&mut self.0, &BadlyNamedUnion::BAZ) + } + } + #[inline] + pub fn into_badly_named_group( + self, + ) -> _p::VariantOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + badly_named_union::BadlyNamedGroup, + > as _p::field::FieldType>::variant( + self.0, + &BadlyNamedUnion::BADLY_NAMED_GROUP, + ) + } + } + #[inline] + pub fn into_baz(self) -> _p::VariantOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + NestedStruct, + > as _p::field::FieldType>::variant(self.0, &BadlyNamedUnion::BAZ) + } + } + #[inline] + pub fn which( + &mut self, + ) -> Result, _p::NotInSchema> { + unsafe { as _p::UnionViewer<_>>::get(self) } + } + } + pub mod badly_named_union { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::BadlyNamedUnion< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::BadlyNamedUnion< + _p::StructBuilder<'a, T>, + >; + pub enum Which { + BadlyNamedGroup(_p::ViewOf>), + Baz(_p::ViewOf>), + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b Reader<'p, T>> + for Which { + type View = Which<&'b Reader<'p, T>>; + unsafe fn get( + repr: &'b Reader<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(3usize); + match tag { + 0u16 => { + Ok( + Which::BadlyNamedGroup( + <_p::Group< + BadlyNamedGroup, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::BadlyNamedUnion::BADLY_NAMED_GROUP.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Baz( + <_p::Struct< + super::NestedStruct, + > as _p::field::FieldType>::accessor( + &repr.0, + &super::BadlyNamedUnion::BAZ.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + impl<'b, 'p: 'b, T: _p::Table + 'p> _p::UnionViewer<&'b mut Builder<'p, T>> + for Which { + type View = Which<&'b mut Builder<'p, T>>; + unsafe fn get( + repr: &'b mut Builder<'p, T>, + ) -> Result { + let tag = repr.0.data_field::(3usize); + match tag { + 0u16 => { + Ok( + Which::BadlyNamedGroup( + <_p::Group< + BadlyNamedGroup, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::BadlyNamedUnion::BADLY_NAMED_GROUP.field, + ), + ), + ) + } + 1u16 => { + Ok( + Which::Baz( + <_p::Struct< + super::NestedStruct, + > as _p::field::FieldType>::accessor( + &mut repr.0, + &super::BadlyNamedUnion::BAZ.field, + ), + ), + ) + } + unknown => Err(_p::NotInSchema(unknown)), + } + } + } + #[derive(Clone)] + pub struct BadlyNamedGroup(T); + impl _p::IntoFamily for BadlyNamedGroup { + type Family = BadlyNamedGroup; + } + impl _p::Capable for BadlyNamedGroup { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = BadlyNamedGroup>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (BadlyNamedGroup(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr + for badly_named_group::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for badly_named_group::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + BadlyNamedGroup(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: badly_named_group::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for badly_named_group::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader + for badly_named_group::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr + for badly_named_group::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl< + 'a, + T: _p::rpc::Table, + > core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: badly_named_group::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for badly_named_group::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for badly_named_group::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder + for badly_named_group::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for BadlyNamedGroup { + type Reader<'a, T: _p::rpc::Table> = badly_named_group::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = badly_named_group::Builder<'a, T>; + } + impl _p::FieldGroup for BadlyNamedGroup { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>( + s: &'a mut _p::StructBuilder<'b, T>, + ) { + <() as _p::field::FieldType>::clear(s, &BadlyNamedGroup::FOO); + <() as _p::field::FieldType>::clear(s, &BadlyNamedGroup::BAR); + } + } + impl BadlyNamedGroup { + const FOO: _p::Descriptor<()> = (); + const BAR: _p::Descriptor<()> = (); + } + impl<'p, T: _p::rpc::Table + 'p> badly_named_group::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::accessor( + &self.0, + &BadlyNamedGroup::FOO, + ) + } + } + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::accessor( + &self.0, + &BadlyNamedGroup::BAR, + ) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> badly_named_group::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::accessor( + &mut self.0, + &BadlyNamedGroup::FOO, + ) + } + } + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, ()> { + unsafe { + <() as _p::field::FieldType>::accessor( + &mut self.0, + &BadlyNamedGroup::BAR, + ) + } + } + } + pub mod badly_named_group { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::BadlyNamedGroup< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::BadlyNamedGroup< + _p::StructBuilder<'a, T>, + >; + } + } +} +#[derive(Clone)] +pub struct TestImpliedFirstField(T); +impl _p::IntoFamily for TestImpliedFirstField { + type Family = TestImpliedFirstField; +} +impl _p::Capable for TestImpliedFirstField { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestImpliedFirstField>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestImpliedFirstField(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_implied_first_field::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_implied_first_field::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestImpliedFirstField(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_implied_first_field::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_implied_first_field::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_implied_first_field::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr +for test_implied_first_field::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_implied_first_field::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_implied_first_field::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_implied_first_field::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_implied_first_field::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestImpliedFirstField { + type Reader<'a, T: _p::rpc::Table> = test_implied_first_field::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_implied_first_field::Builder<'a, T>; +} +impl _p::ty::Struct for TestImpliedFirstField { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 3u16, + }; +} +impl TestImpliedFirstField { + const TEXT_STRUCT: _p::Descriptor< + _p::Struct, + > = _p::Descriptor::<_p::Struct> { + slot: 0u32, + default: ::core::option::Option::Some(unsafe { + _p::StructReader::slice_unchecked( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([102u8, 111u8, 111u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + _p::StructSize { + data: 1u16, + ptrs: 1u16, + }, + ) + }), + }; + const TEXT_STRUCT_LIST: _p::Descriptor< + _p::List<_p::Struct>, + > = _p::Descriptor::<_p::List<_p::Struct>> { + slot: 1u32, + default: ::core::option::Option::None, + }; + const INT_GROUP: _p::Descriptor<_p::Group> = (); +} +impl<'p, T: _p::rpc::Table + 'p> test_implied_first_field::Reader<'p, T> { + #[inline] + pub fn text_struct( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_implied_first_field::TextStruct, + > as _p::field::FieldType>::accessor( + &self.0, + &TestImpliedFirstField::TEXT_STRUCT, + ) + } + } + #[inline] + pub fn text_struct_list( + &self, + ) -> _p::Accessor< + '_, + 'p, + T, + _p::List<_p::Struct>, + > { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor( + &self.0, + &TestImpliedFirstField::TEXT_STRUCT_LIST, + ) + } + } + #[inline] + pub fn int_group( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_implied_first_field::IntGroup, + > as _p::field::FieldType>::accessor( + &self.0, + &TestImpliedFirstField::INT_GROUP, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_implied_first_field::Builder<'p, T> { + #[inline] + pub fn text_struct( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_implied_first_field::TextStruct, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestImpliedFirstField::TEXT_STRUCT, + ) + } + } + #[inline] + pub fn text_struct_list( + &mut self, + ) -> _p::AccessorMut< + '_, + 'p, + T, + _p::List<_p::Struct>, + > { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestImpliedFirstField::TEXT_STRUCT_LIST, + ) + } + } + #[inline] + pub fn int_group( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::Group> { + unsafe { + <_p::Group< + test_implied_first_field::IntGroup, + > as _p::field::FieldType>::accessor( + &mut self.0, + &TestImpliedFirstField::INT_GROUP, + ) + } + } + #[inline] + pub fn into_text_struct( + self, + ) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + test_implied_first_field::TextStruct, + > as _p::field::FieldType>::accessor( + self.0, + &TestImpliedFirstField::TEXT_STRUCT, + ) + } + } + #[inline] + pub fn into_text_struct_list( + self, + ) -> _p::AccessorOwned< + 'p, + T, + _p::List<_p::Struct>, + > { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor( + self.0, + &TestImpliedFirstField::TEXT_STRUCT_LIST, + ) + } + } + #[inline] + pub fn into_int_group( + self, + ) -> _p::AccessorOwned<'p, T, _p::Group> { + unsafe { + <_p::Group< + test_implied_first_field::IntGroup, + > as _p::field::FieldType>::accessor( + self.0, + &TestImpliedFirstField::INT_GROUP, + ) + } + } +} +pub mod test_implied_first_field { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestImpliedFirstField< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestImpliedFirstField< + _p::StructBuilder<'a, T>, + >; + #[derive(Clone)] + pub struct TextStruct(T); + impl _p::IntoFamily for TextStruct { + type Family = TextStruct; + } + impl _p::Capable for TextStruct { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TextStruct>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TextStruct(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for text_struct::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for text_struct::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TextStruct(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: text_struct::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for text_struct::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for text_struct::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for text_struct::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: text_struct::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for text_struct::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for text_struct::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for text_struct::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for TextStruct { + type Reader<'a, T: _p::rpc::Table> = text_struct::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = text_struct::Builder<'a, T>; + } + impl _p::ty::Struct for TextStruct { + const SIZE: _p::StructSize = _p::StructSize { + data: 1u16, + ptrs: 1u16, + }; + } + impl TextStruct { + const TEXT: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 0u32, + default: ::core::option::Option::None, + }; + const I: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 321u32, + }; + } + impl<'p, T: _p::rpc::Table + 'p> text_struct::Reader<'p, T> { + #[inline] + pub fn text(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &TextStruct::TEXT) + } + } + #[inline] + pub fn i(&self) -> _p::Accessor<'_, 'p, T, u32> { + unsafe { ::accessor(&self.0, &TextStruct::I) } + } + } + impl<'p, T: _p::rpc::Table + 'p> text_struct::Builder<'p, T> { + #[inline] + pub fn text(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor( + &mut self.0, + &TextStruct::TEXT, + ) + } + } + #[inline] + pub fn i(&mut self) -> _p::AccessorMut<'_, 'p, T, u32> { + unsafe { + ::accessor(&mut self.0, &TextStruct::I) + } + } + #[inline] + pub fn into_text(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &TextStruct::TEXT) + } + } + } + pub mod text_struct { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TextStruct< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TextStruct< + _p::StructBuilder<'a, T>, + >; + } + #[derive(Clone)] + pub struct IntGroup(T); + impl _p::IntoFamily for IntGroup { + type Family = IntGroup; + } + impl _p::Capable for IntGroup { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = IntGroup>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (IntGroup(imbued), old) + } + #[inline] + fn imbue_release_into( + &self, + other: U, + ) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } + } + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for int_group::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> + for int_group::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + IntGroup(ptr) + } + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructReader<'a, T> { + #[inline] + fn from(reader: int_group::Reader<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> + for int_group::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructReader for int_group::Reader<'a, T> {} + impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for int_group::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; + } + impl<'a, T: _p::rpc::Table> core::convert::From> + for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: int_group::Builder<'a, T>) -> Self { + reader.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> + for int_group::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } + } + impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> + for int_group::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } + } + impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder for int_group::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } + } + impl _p::StructView for IntGroup { + type Reader<'a, T: _p::rpc::Table> = int_group::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = int_group::Builder<'a, T>; + } + impl _p::FieldGroup for IntGroup { + unsafe fn clear<'a, 'b, T: _p::rpc::Table>(s: &'a mut _p::StructBuilder<'b, T>) { + ::clear(s, &IntGroup::I); + <_p::Text as _p::field::FieldType>::clear(s, &IntGroup::STR); + } + } + impl IntGroup { + const I: _p::Descriptor = _p::Descriptor:: { + slot: 0u32, + default: 0u32, + }; + const STR: _p::Descriptor<_p::Text> = _p::Descriptor::<_p::Text> { + slot: 2u32, + default: ::core::option::Option::Some( + _p::text::Reader::from_slice(b"corge\0"), + ), + }; + } + impl<'p, T: _p::rpc::Table + 'p> int_group::Reader<'p, T> { + #[inline] + pub fn i(&self) -> _p::Accessor<'_, 'p, T, u32> { + unsafe { ::accessor(&self.0, &IntGroup::I) } + } + #[inline] + pub fn str(&self) -> _p::Accessor<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&self.0, &IntGroup::STR) + } + } + } + impl<'p, T: _p::rpc::Table + 'p> int_group::Builder<'p, T> { + #[inline] + pub fn i(&mut self) -> _p::AccessorMut<'_, 'p, T, u32> { + unsafe { ::accessor(&mut self.0, &IntGroup::I) } + } + #[inline] + pub fn str(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(&mut self.0, &IntGroup::STR) + } + } + #[inline] + pub fn into_str(self) -> _p::AccessorOwned<'p, T, _p::Text> { + unsafe { + <_p::Text as _p::field::FieldType>::accessor(self.0, &IntGroup::STR) + } + } + } + pub mod int_group { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::IntGroup< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::IntGroup< + _p::StructBuilder<'a, T>, + >; + } +} +pub const TEST_IMPLIED_FIRST_FIELD: _p::ty::ConstPtr< + _p::Struct, +> = unsafe { + _p::ty::ConstPtr::new( + &[ + _p::Word([0u8, 0u8, 0u8, 0u8, 1u8, 0u8, 3u8, 0u8]), + _p::Word([123u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 1u8, 0u8]), + _p::Word([17u8, 0u8, 0u8, 0u8, 39u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([1u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 114u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([8u8, 0u8, 0u8, 0u8, 1u8, 0u8, 1u8, 0u8]), + _p::Word([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([9u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([58u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([5u8, 0u8, 0u8, 0u8, 34u8, 0u8, 0u8, 0u8]), + _p::Word([98u8, 97u8, 122u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + _p::Word([113u8, 117u8, 120u8, 0u8, 0u8, 0u8, 0u8, 0u8]), + ], + ) +}; +#[derive(Clone)] +pub struct TestCycleANoCaps(T); +impl _p::IntoFamily for TestCycleANoCaps { + type Family = TestCycleANoCaps; +} +impl _p::Capable for TestCycleANoCaps { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestCycleANoCaps>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestCycleANoCaps(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_cycle_a_no_caps::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_cycle_a_no_caps::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestCycleANoCaps(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_cycle_a_no_caps::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_cycle_a_no_caps::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_cycle_a_no_caps::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_cycle_a_no_caps::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_cycle_a_no_caps::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_cycle_a_no_caps::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_cycle_a_no_caps::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_cycle_a_no_caps::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestCycleANoCaps { + type Reader<'a, T: _p::rpc::Table> = test_cycle_a_no_caps::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_cycle_a_no_caps::Builder<'a, T>; +} +impl _p::ty::Struct for TestCycleANoCaps { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; +} +impl TestCycleANoCaps { + const FOO: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_cycle_a_no_caps::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestCycleBNoCaps, + > as _p::field::FieldType>::accessor(&self.0, &TestCycleANoCaps::FOO) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_cycle_a_no_caps::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestCycleBNoCaps, + > as _p::field::FieldType>::accessor(&mut self.0, &TestCycleANoCaps::FOO) + } + } + #[inline] + pub fn into_foo(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestCycleBNoCaps, + > as _p::field::FieldType>::accessor(self.0, &TestCycleANoCaps::FOO) + } + } +} +pub mod test_cycle_a_no_caps { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestCycleANoCaps< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestCycleANoCaps< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestCycleBNoCaps(T); +impl _p::IntoFamily for TestCycleBNoCaps { + type Family = TestCycleBNoCaps; +} +impl _p::Capable for TestCycleBNoCaps { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestCycleBNoCaps>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestCycleBNoCaps(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_cycle_b_no_caps::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_cycle_b_no_caps::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestCycleBNoCaps(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_cycle_b_no_caps::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_cycle_b_no_caps::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_cycle_b_no_caps::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_cycle_b_no_caps::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_cycle_b_no_caps::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_cycle_b_no_caps::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_cycle_b_no_caps::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_cycle_b_no_caps::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestCycleBNoCaps { + type Reader<'a, T: _p::rpc::Table> = test_cycle_b_no_caps::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_cycle_b_no_caps::Builder<'a, T>; +} +impl _p::ty::Struct for TestCycleBNoCaps { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 2u16, + }; +} +impl TestCycleBNoCaps { + const FOO: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; + const BAR: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 1u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_cycle_b_no_caps::Reader<'p, T> { + #[inline] + pub fn foo( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestCycleBNoCaps::FOO) + } + } + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestAllTypes, + > as _p::field::FieldType>::accessor(&self.0, &TestCycleBNoCaps::BAR) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_cycle_b_no_caps::Builder<'p, T> { + #[inline] + pub fn foo( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestCycleBNoCaps::FOO) + } + } + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestAllTypes, + > as _p::field::FieldType>::accessor(&mut self.0, &TestCycleBNoCaps::BAR) + } + } + #[inline] + pub fn into_foo( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestCycleBNoCaps::FOO) + } + } + #[inline] + pub fn into_bar(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestAllTypes, + > as _p::field::FieldType>::accessor(self.0, &TestCycleBNoCaps::BAR) + } + } +} +pub mod test_cycle_b_no_caps { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestCycleBNoCaps< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestCycleBNoCaps< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestCycleAWithCaps(T); +impl _p::IntoFamily for TestCycleAWithCaps { + type Family = TestCycleAWithCaps; +} +impl _p::Capable for TestCycleAWithCaps { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestCycleAWithCaps>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestCycleAWithCaps(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_cycle_a_with_caps::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_cycle_a_with_caps::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestCycleAWithCaps(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_cycle_a_with_caps::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_cycle_a_with_caps::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_cycle_a_with_caps::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_cycle_a_with_caps::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_cycle_a_with_caps::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_cycle_a_with_caps::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_cycle_a_with_caps::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_cycle_a_with_caps::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestCycleAWithCaps { + type Reader<'a, T: _p::rpc::Table> = test_cycle_a_with_caps::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_cycle_a_with_caps::Builder<'a, T>; +} +impl _p::ty::Struct for TestCycleAWithCaps { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 1u16, + }; +} +impl TestCycleAWithCaps { + const FOO: _p::Descriptor<_p::Struct> = _p::Descriptor::< + _p::Struct, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_cycle_a_with_caps::Reader<'p, T> { + #[inline] + pub fn foo(&self) -> _p::Accessor<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestCycleBWithCaps, + > as _p::field::FieldType>::accessor(&self.0, &TestCycleAWithCaps::FOO) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_cycle_a_with_caps::Builder<'p, T> { + #[inline] + pub fn foo(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestCycleBWithCaps, + > as _p::field::FieldType>::accessor(&mut self.0, &TestCycleAWithCaps::FOO) + } + } + #[inline] + pub fn into_foo(self) -> _p::AccessorOwned<'p, T, _p::Struct> { + unsafe { + <_p::Struct< + TestCycleBWithCaps, + > as _p::field::FieldType>::accessor(self.0, &TestCycleAWithCaps::FOO) + } + } +} +pub mod test_cycle_a_with_caps { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestCycleAWithCaps< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestCycleAWithCaps< + _p::StructBuilder<'a, T>, + >; +} +#[derive(Clone)] +pub struct TestCycleBWithCaps(T); +impl _p::IntoFamily for TestCycleBWithCaps { + type Family = TestCycleBWithCaps; +} +impl _p::Capable for TestCycleBWithCaps { + type Table = T::Table; + type Imbued = T::Imbued; + type ImbuedWith = TestCycleBWithCaps>; + #[inline] + fn imbued(&self) -> &Self::Imbued { + self.0.imbued() + } + #[inline] + fn imbue_release( + self, + new_table: as _p::Capable>::Imbued, + ) -> (Self::ImbuedWith, Self::Imbued) { + let (imbued, old) = self.0.imbue_release(new_table); + (TestCycleBWithCaps(imbued), old) + } + #[inline] + fn imbue_release_into(&self, other: U) -> (U::ImbuedWith, U::Imbued) + where + U: _p::Capable, + U::ImbuedWith: _p::Capable, + { + self.0.imbue_release_into(other) + } +} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_cycle_b_with_caps::Reader<'a, T> { + type Ptr = _p::StructReader<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From<_p::StructReader<'a, T>> +for test_cycle_b_with_caps::Reader<'a, T> { + #[inline] + fn from(ptr: _p::StructReader<'a, T>) -> Self { + TestCycleBWithCaps(ptr) + } +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructReader<'a, T> { + #[inline] + fn from(reader: test_cycle_b_with_caps::Reader<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructReader<'a, T>> +for test_cycle_b_with_caps::Reader<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructReader<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructReader +for test_cycle_b_with_caps::Reader<'a, T> {} +impl<'a, T: _p::rpc::Table> _p::ty::TypedPtr for test_cycle_b_with_caps::Builder<'a, T> { + type Ptr = _p::StructBuilder<'a, T>; +} +impl<'a, T: _p::rpc::Table> core::convert::From> +for _p::StructBuilder<'a, T> { + #[inline] + fn from(reader: test_cycle_b_with_caps::Builder<'a, T>) -> Self { + reader.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsRef<_p::StructBuilder<'a, T>> +for test_cycle_b_with_caps::Builder<'a, T> { + #[inline] + fn as_ref(&self) -> &_p::StructBuilder<'a, T> { + &self.0 + } +} +impl<'a, T: _p::rpc::Table> core::convert::AsMut<_p::StructBuilder<'a, T>> +for test_cycle_b_with_caps::Builder<'a, T> { + #[inline] + fn as_mut(&mut self) -> &mut _p::StructBuilder<'a, T> { + &mut self.0 + } +} +impl<'a, T: _p::rpc::Table> _p::ty::StructBuilder +for test_cycle_b_with_caps::Builder<'a, T> { + unsafe fn from_ptr(ptr: Self::Ptr) -> Self { + Self(ptr) + } +} +impl _p::StructView for TestCycleBWithCaps { + type Reader<'a, T: _p::rpc::Table> = test_cycle_b_with_caps::Reader<'a, T>; + type Builder<'a, T: _p::rpc::Table> = test_cycle_b_with_caps::Builder<'a, T>; +} +impl _p::ty::Struct for TestCycleBWithCaps { + const SIZE: _p::StructSize = _p::StructSize { + data: 0u16, + ptrs: 2u16, + }; +} +impl TestCycleBWithCaps { + const FOO: _p::Descriptor<_p::List<_p::Struct>> = _p::Descriptor::< + _p::List<_p::Struct>, + > { + slot: 0u32, + default: ::core::option::Option::None, + }; + const BAR: _p::Descriptor<_p::AnyPtr> = _p::Descriptor::<_p::AnyPtr> { + slot: 1u32, + default: ::core::option::Option::None, + }; +} +impl<'p, T: _p::rpc::Table + 'p> test_cycle_b_with_caps::Reader<'p, T> { + #[inline] + pub fn foo( + &self, + ) -> _p::Accessor<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&self.0, &TestCycleBWithCaps::FOO) + } + } + #[inline] + pub fn bar(&self) -> _p::Accessor<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &self.0, + &TestCycleBWithCaps::BAR, + ) + } + } +} +impl<'p, T: _p::rpc::Table + 'p> test_cycle_b_with_caps::Builder<'p, T> { + #[inline] + pub fn foo( + &mut self, + ) -> _p::AccessorMut<'_, 'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(&mut self.0, &TestCycleBWithCaps::FOO) + } + } + #[inline] + pub fn bar(&mut self) -> _p::AccessorMut<'_, 'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + &mut self.0, + &TestCycleBWithCaps::BAR, + ) + } + } + #[inline] + pub fn into_foo( + self, + ) -> _p::AccessorOwned<'p, T, _p::List<_p::Struct>> { + unsafe { + <_p::List< + _p::Struct, + > as _p::field::FieldType>::accessor(self.0, &TestCycleBWithCaps::FOO) + } + } + #[inline] + pub fn into_bar(self) -> _p::AccessorOwned<'p, T, _p::AnyPtr> { + unsafe { + <_p::AnyPtr as _p::field::FieldType>::accessor( + self.0, + &TestCycleBWithCaps::BAR, + ) + } + } +} +pub mod test_cycle_b_with_caps { + use super::{__file, __imports, _p}; + pub type Reader<'a, T = _p::rpc::Empty> = super::TestCycleBWithCaps< + _p::StructReader<'a, T>, + >; + pub type Builder<'a, T = _p::rpc::Empty> = super::TestCycleBWithCaps< + _p::StructBuilder<'a, T>, + >; +} diff --git a/tests/src/gen/capnp/testdata/binary b/tests/src/gen/capnp/testdata/binary new file mode 100644 index 0000000..ea39763 Binary files /dev/null and b/tests/src/gen/capnp/testdata/binary differ diff --git a/tests/src/gen/capnp/testdata/packed b/tests/src/gen/capnp/testdata/packed new file mode 100644 index 0000000..8627833 Binary files /dev/null and b/tests/src/gen/capnp/testdata/packed differ diff --git a/tests/src/gen/capnp/testdata/short.txt b/tests/src/gen/capnp/testdata/short.txt new file mode 100644 index 0000000..d738fb3 --- /dev/null +++ b/tests/src/gen/capnp/testdata/short.txt @@ -0,0 +1 @@ +(voidField = void, boolField = true, int8Field = -123, int16Field = -12345, int32Field = -12345678, int64Field = -123456789012345, uInt8Field = 234, uInt16Field = 45678, uInt32Field = 3456789012, uInt64Field = 12345678901234567890, float32Field = 1234.5, float64Field = -1.23e47, textField = "foo", dataField = "bar", structField = (voidField = void, boolField = true, int8Field = -12, int16Field = 3456, int32Field = -78901234, int64Field = 56789012345678, uInt8Field = 90, uInt16Field = 1234, uInt32Field = 56789012, uInt64Field = 345678901234567890, float32Field = -1.25e-10, float64Field = 345, textField = "baz", dataField = "qux", structField = (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "nested", structField = (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "really nested", enumField = foo, interfaceField = void), enumField = foo, interfaceField = void), enumField = baz, interfaceField = void, voidList = [void, void, void], boolList = [false, true, false, true, true], int8List = [12, -34, -128, 127], int16List = [1234, -5678, -32768, 32767], int32List = [12345678, -90123456, -2147483648, 2147483647], int64List = [123456789012345, -678901234567890, -9223372036854775808, 9223372036854775807], uInt8List = [12, 34, 0, 255], uInt16List = [1234, 5678, 0, 65535], uInt32List = [12345678, 90123456, 0, 4294967295], uInt64List = [123456789012345, 678901234567890, 0, 18446744073709551615], float32List = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37], float64List = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], textList = ["quux", "corge", "grault"], dataList = ["garply", "waldo", "fred"], structList = [(voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "x structlist 1", enumField = foo, interfaceField = void), (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "x structlist 2", enumField = foo, interfaceField = void), (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "x structlist 3", enumField = foo, interfaceField = void)], enumList = [qux, bar, grault]), enumField = corge, interfaceField = void, voidList = [void, void, void, void, void, void], boolList = [true, false, false, true], int8List = [111, -111], int16List = [11111, -11111], int32List = [111111111, -111111111], int64List = [1111111111111111111, -1111111111111111111], uInt8List = [111, 222], uInt16List = [33333, 44444], uInt32List = [3333333333], uInt64List = [11111111111111111111], float32List = [5555.5, inf, -inf, nan], float64List = [7777.75, inf, -inf, nan], textList = ["plugh", "xyzzy", "thud"], dataList = ["oops", "exhausted", "rfc3092"], structList = [(voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "structlist 1", enumField = foo, interfaceField = void), (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "structlist 2", enumField = foo, interfaceField = void), (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "structlist 3", enumField = foo, interfaceField = void)], enumList = [foo, garply]) diff --git a/tests/src/gen/regenerate.ps1 b/tests/src/gen/regenerate.ps1 index 9b48234..97c1f1c 100644 --- a/tests/src/gen/regenerate.ps1 +++ b/tests/src/gen/regenerate.ps1 @@ -6,7 +6,7 @@ $files = @( try { Push-Location $PSScriptRoot - $command = "capnp compile $($files -join ' ') -o- | cargo run -p recapnc --bin capnpc-rust" + $command = "capnp compile $($files -join ' ') -I. --no-standard-import -o- | cargo run -p recapnc --bin capnpc-rust" cmd /c $command } finally { diff --git a/tests/src/gen/regenerate.sh b/tests/src/gen/regenerate.sh index 4ae3cb5..4350b13 100755 --- a/tests/src/gen/regenerate.sh +++ b/tests/src/gen/regenerate.sh @@ -8,4 +8,4 @@ files=( "capnp/test-import2.capnp" ) -capnp compile ${files[*]} -o- | cargo run -p recapnc --bin capnpc-rust \ No newline at end of file +capnp compile ${files[*]} -I. --no-standard-import -o- | cargo run -p recapnc --bin capnpc-rust \ No newline at end of file