pub mod unknown_fields {
#![allow(warnings, clippy::all)]
pub mod must_gen_items {
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct A {
pub a: ::std::option::Option<i32>,
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for A {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier { name: "A" };
__protocol.write_struct_begin(&struct_ident)?;
if let Some(value) = self.a.as_ref() {
__protocol.write_i32_field(1, *value)?;
}
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut var_1 = None;
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
var_1 = Some(__protocol.read_i32()?);
}
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `A` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self {
a: var_1,
_unknown_fields,
};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut var_1 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type == ::pilota::thrift::TType::I32 =>
{
var_1 = Some(__protocol.read_i32().await?);
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `A` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {
a: var_1,
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "A" })
+ self
.a
.as_ref()
.map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct B {
pub a: ::std::option::Option<A>,
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for B {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
__protocol.write_struct_begin(&struct_ident)?;
if let Some(value) = self.a.as_ref() {
__protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
}
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut var_2 = None;
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(2)
if field_ident.field_type == ::pilota::thrift::TType::Struct =>
{
var_2 = Some(::pilota::thrift::Message::decode(__protocol)?);
}
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `B` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self {
a: var_2,
_unknown_fields,
};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut var_2 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(2)
if field_ident.field_type
== ::pilota::thrift::TType::Struct =>
{
var_2 = Some(
<A as ::pilota::thrift::Message>::decode_async(__protocol)
.await?,
);
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `B` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {
a: var_2,
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
+ self
.a
.as_ref()
.map_or(0, |value| __protocol.struct_field_len(Some(2), value))
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
}
pub mod unknown_fields {
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct A {
pub bytes: ::pilota::Bytes,
pub vec: ::std::vec::Vec<u8>,
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for A {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier { name: "A" };
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_bytes_field(1, (&self.bytes).clone())?;
__protocol.write_bytes_vec_field(2, &self.vec)?;
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut var_1 = None;
let mut var_2 = None;
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type == ::pilota::thrift::TType::Binary =>
{
var_1 = Some(__protocol.read_bytes()?);
}
Some(2)
if field_ident.field_type == ::pilota::thrift::TType::Binary =>
{
var_2 = Some(__protocol.read_bytes_vec()?);
}
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `A` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field bytes is required".to_string(),
));
};
let Some(var_2) = var_2 else {
return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field vec is required".to_string(),
));
};
let data = Self {
bytes: var_1,
vec: var_2,
_unknown_fields,
};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut var_1 = None;
let mut var_2 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type
== ::pilota::thrift::TType::Binary =>
{
var_1 = Some(__protocol.read_bytes().await?);
}
Some(2)
if field_ident.field_type
== ::pilota::thrift::TType::Binary =>
{
var_2 = Some(__protocol.read_bytes_vec().await?);
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `A` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field bytes is required".to_string(),
),
);
};
let Some(var_2) = var_2 else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field vec is required".to_string(),
),
);
};
let data = Self {
bytes: var_1,
vec: var_2,
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "A" })
+ __protocol.bytes_field_len(Some(1), &self.bytes)
+ __protocol.bytes_vec_field_len(Some(2), &self.vec)
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct D {
pub td: Td,
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for D {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier { name: "D" };
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_struct_field(1, &self.td, ::pilota::thrift::TType::List)?;
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut var_1 = None;
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
var_1 = Some(::pilota::thrift::Message::decode(__protocol)?);
}
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `D` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field td is required".to_string(),
));
};
let data = Self {
td: var_1,
_unknown_fields,
};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut var_1 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type == ::pilota::thrift::TType::List =>
{
var_1 = Some(
<Td as ::pilota::thrift::Message>::decode_async(__protocol)
.await?,
);
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `D` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field td is required".to_string(),
),
);
};
let data = Self {
td: var_1,
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "D" })
+ __protocol.struct_field_len(Some(1), &self.td)
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
pub trait Test {}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct TestTest123ArgsSend {}
impl ::pilota::thrift::Message for TestTest123ArgsSend {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier {
name: "TestTest123ArgsSend",
};
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
__protocol.read_field_end()?;
__protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self {};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ArgsSend",
}) + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
pub const TEST_LIST: [&'static str; 2] = ["hello", "world"];
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct B {
pub faststr: ::pilota::FastStr,
pub string: ::std::string::String,
pub list: ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>,
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for B {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_faststr_field(1, (&self.faststr).clone())?;
__protocol.write_string_field(2, &self.string)?;
__protocol.write_list_field(
3,
::pilota::thrift::TType::List,
&&self.list,
|__protocol, val| {
__protocol.write_list(
::pilota::thrift::TType::Binary,
&val,
|__protocol, val| {
__protocol.write_faststr((val).clone())?;
::std::result::Result::Ok(())
},
)?;
::std::result::Result::Ok(())
},
)?;
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut var_1 = None;
let mut var_2 = None;
let mut var_3 = None;
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type == ::pilota::thrift::TType::Binary =>
{
var_1 = Some(__protocol.read_faststr()?);
}
Some(2)
if field_ident.field_type == ::pilota::thrift::TType::Binary =>
{
var_2 = Some(__protocol.read_string()?);
}
Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
var_3 = Some(unsafe {
let list_ident = __protocol.read_list_begin()?;
let mut val: ::std::vec::Vec<
::std::vec::Vec<::pilota::FastStr>,
> = ::std::vec::Vec::with_capacity(list_ident.size);
for i in 0..list_ident.size {
val.as_mut_ptr().offset(i as isize).write(unsafe {
let list_ident = __protocol.read_list_begin()?;
let mut val: ::std::vec::Vec<::pilota::FastStr> =
::std::vec::Vec::with_capacity(list_ident.size);
for i in 0..list_ident.size {
val.as_mut_ptr()
.offset(i as isize)
.write(__protocol.read_faststr()?);
}
val.set_len(list_ident.size);
__protocol.read_list_end()?;
val
});
}
val.set_len(list_ident.size);
__protocol.read_list_end()?;
val
});
}
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `B` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field faststr is required".to_string(),
));
};
let Some(var_2) = var_2 else {
return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field string is required".to_string(),
));
};
let Some(var_3) = var_3 else {
return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field list is required".to_string(),
));
};
let data = Self {
faststr: var_1,
string: var_2,
list: var_3,
_unknown_fields,
};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut var_1 = None;
let mut var_2 = None;
let mut var_3 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type
== ::pilota::thrift::TType::Binary =>
{
var_1 = Some(__protocol.read_faststr().await?);
}
Some(2)
if field_ident.field_type
== ::pilota::thrift::TType::Binary =>
{
var_2 = Some(__protocol.read_string().await?);
}
Some(3)
if field_ident.field_type == ::pilota::thrift::TType::List =>
{
var_3 = Some({
let list_ident = __protocol.read_list_begin().await?;
let mut val =
::std::vec::Vec::with_capacity(list_ident.size);
for _ in 0..list_ident.size {
val.push({
let list_ident =
__protocol.read_list_begin().await?;
let mut val =
::std::vec::Vec::with_capacity(list_ident.size);
for _ in 0..list_ident.size {
val.push(__protocol.read_faststr().await?);
}
__protocol.read_list_end().await?;
val
});
}
__protocol.read_list_end().await?;
val
});
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `B` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field faststr is required".to_string(),
),
);
};
let Some(var_2) = var_2 else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field string is required".to_string(),
),
);
};
let Some(var_3) = var_3 else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field list is required".to_string(),
),
);
};
let data = Self {
faststr: var_1,
string: var_2,
list: var_3,
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
+ __protocol.faststr_field_len(Some(1), &self.faststr)
+ __protocol.string_field_len(Some(2), &&self.string)
+ __protocol.list_field_len(
Some(3),
::pilota::thrift::TType::List,
&self.list,
|__protocol, el| {
__protocol.list_len(
::pilota::thrift::TType::Binary,
el,
|__protocol, el| __protocol.faststr_len(el),
)
},
)
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct SubMessage {
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for SubMessage {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier { name: "SubMessage" };
__protocol.write_struct_begin(&struct_ident)?;
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `SubMessage` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self { _unknown_fields };
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `SubMessage` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol
.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "SubMessage" })
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct StException {
pub message: ::std::option::Option<::pilota::FastStr>,
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for StException {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier {
name: "StException",
};
__protocol.write_struct_begin(&struct_ident)?;
if let Some(value) = self.message.as_ref() {
__protocol.write_faststr_field(1, (value).clone())?;
}
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut var_1 = None;
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type == ::pilota::thrift::TType::Binary =>
{
var_1 = Some(__protocol.read_faststr()?);
}
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `StException` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self {
message: var_1,
_unknown_fields,
};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut var_1 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type
== ::pilota::thrift::TType::Binary =>
{
var_1 = Some(__protocol.read_faststr().await?);
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `StException` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {
message: var_1,
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "StException",
}) + self
.message
.as_ref()
.map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct TestTest123ArgsRecv {}
impl ::pilota::thrift::Message for TestTest123ArgsRecv {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier {
name: "TestTest123ArgsRecv",
};
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
__protocol.read_field_end()?;
__protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self {};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ArgsRecv",
}) + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
pub static TEST_MAP_LIST: ::std::sync::LazyLock<
::pilota::AHashMap<i32, ::std::vec::Vec<&'static str>>,
> = ::std::sync::LazyLock::new(|| {
let mut map = ::pilota::AHashMap::with_capacity(1);
map.insert(1i32, ::std::vec!["hello"]);
map
});
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct C {
pub a: super::must_gen_items::A,
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for C {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_struct_field(1, &self.a, ::pilota::thrift::TType::Struct)?;
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut var_1 = None;
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type == ::pilota::thrift::TType::Struct =>
{
var_1 = Some(::pilota::thrift::Message::decode(__protocol)?);
}
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `C` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field a is required".to_string(),
));
};
let data = Self {
a: var_1,
_unknown_fields,
};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut var_1 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1) if field_ident.field_type == ::pilota::thrift::TType::Struct => {
var_1 = Some(<super::must_gen_items::A as ::pilota::thrift::Message>::decode_async(__protocol).await?);
},
_ => {
__protocol.skip(field_ident.field_type).await?;
},
}
__protocol.read_field_end().await?;
};
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}.await {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!("decode struct `C` field(#{}) failed, caused by: ", field_id));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field a is required".to_string(),
),
);
};
let data = Self {
a: var_1,
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
+ __protocol.struct_field_len(Some(1), &self.a)
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct Message {
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for Message {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Message" };
__protocol.write_struct_begin(&struct_ident)?;
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `Message` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self { _unknown_fields };
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `Message` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol
.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Message" })
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
impl ::std::default::Default for TestUnion {
fn default() -> Self {
TestUnion::A(::std::default::Default::default())
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub enum TestUnion {
A(A),
B(B),
_UnknownFields(::pilota::BytesVec),
}
impl ::pilota::thrift::Message for TestUnion {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
name: "TestUnion",
})?;
match self {
TestUnion::A(value) => {
__protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
}
TestUnion::B(value) => {
__protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
}
TestUnion::_UnknownFields(value) => {
for bytes in value.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
}
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut ret = None;
__protocol.read_struct_begin()?;
loop {
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
match field_ident.id {
Some(1) => {
if ret.is_none() {
let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
__pilota_offset += __protocol.struct_len(&field_ident);
ret = Some(TestUnion::A(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
Some(2) => {
if ret.is_none() {
let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
__pilota_offset += __protocol.struct_len(&field_ident);
ret = Some(TestUnion::B(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
if ret.is_none() {
unsafe {
let mut __pilota_linked_bytes = ::pilota::BytesVec::new();
__pilota_linked_bytes.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
ret = Some(TestUnion::_UnknownFields(__pilota_linked_bytes));
}
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
}
}
__protocol.read_field_end()?;
__protocol.read_struct_end()?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received empty union from remote Message",
))
}
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut ret = None;
__protocol.read_struct_begin().await?;
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
match field_ident.id {
Some(1) => {
if ret.is_none() {
let field_ident =
<A as ::pilota::thrift::Message>::decode_async(__protocol)
.await?;
ret = Some(TestUnion::A(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
Some(2) => {
if ret.is_none() {
let field_ident =
<B as ::pilota::thrift::Message>::decode_async(__protocol)
.await?;
ret = Some(TestUnion::B(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
}
__protocol.read_field_end().await?;
__protocol.read_struct_end().await?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received empty union from remote Message",
))
}
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol
.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "TestUnion" })
+ match self {
TestUnion::A(value) => __protocol.struct_field_len(Some(1), value),
TestUnion::B(value) => __protocol.struct_field_len(Some(2), value),
TestUnion::_UnknownFields(value) => value.size(),
}
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
impl ::std::default::Default for TestTestExceptionException {
fn default() -> Self {
TestTestExceptionException::StException(::std::default::Default::default())
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub enum TestTestExceptionException {
StException(StException),
}
impl ::pilota::thrift::Message for TestTestExceptionException {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionException",
})?;
match self {
TestTestExceptionException::StException(value) => {
__protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
}
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut ret = None;
__protocol.read_struct_begin()?;
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
match field_ident.id {
Some(1) => {
if ret.is_none() {
let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
__protocol.struct_len(&field_ident);
ret = Some(TestTestExceptionException::StException(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
}
__protocol.read_field_end()?;
__protocol.read_struct_end()?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received empty union from remote Message",
))
}
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut ret = None;
__protocol.read_struct_begin().await?;
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
match field_ident.id {
Some(1) => {
if ret.is_none() {
let field_ident =
<StException as ::pilota::thrift::Message>::decode_async(
__protocol,
)
.await?;
ret =
Some(TestTestExceptionException::StException(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
}
__protocol.read_field_end().await?;
__protocol.read_struct_end().await?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received empty union from remote Message",
))
}
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionException",
}) + match self {
TestTestExceptionException::StException(value) => {
__protocol.struct_field_len(Some(1), value)
}
} + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
impl ::std::default::Default for TestTestExceptionResultRecv {
fn default() -> Self {
TestTestExceptionResultRecv::Ok(::std::default::Default::default())
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub enum TestTestExceptionResultRecv {
Ok(ObjReq),
StException(StException),
}
impl ::pilota::thrift::Message for TestTestExceptionResultRecv {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionResultRecv",
})?;
match self {
TestTestExceptionResultRecv::Ok(value) => {
__protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
}
TestTestExceptionResultRecv::StException(value) => {
__protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
}
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut ret = None;
__protocol.read_struct_begin()?;
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
match field_ident.id {
Some(0) => {
if ret.is_none() {
let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
__protocol.struct_len(&field_ident);
ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
Some(1) => {
if ret.is_none() {
let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
__protocol.struct_len(&field_ident);
ret = Some(TestTestExceptionResultRecv::StException(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
}
__protocol.read_field_end()?;
__protocol.read_struct_end()?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received empty union from remote Message",
))
}
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut ret = None;
__protocol.read_struct_begin().await?;
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
match field_ident.id {
Some(0) => {
if ret.is_none() {
let field_ident =
<ObjReq as ::pilota::thrift::Message>::decode_async(
__protocol,
)
.await?;
ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
Some(1) => {
if ret.is_none() {
let field_ident =
<StException as ::pilota::thrift::Message>::decode_async(
__protocol,
)
.await?;
ret =
Some(TestTestExceptionResultRecv::StException(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
}
__protocol.read_field_end().await?;
__protocol.read_struct_end().await?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received empty union from remote Message",
))
}
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionResultRecv",
}) + match self {
TestTestExceptionResultRecv::Ok(value) => {
__protocol.struct_field_len(Some(0), value)
}
TestTestExceptionResultRecv::StException(value) => {
__protocol.struct_field_len(Some(1), value)
}
} + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
impl ::std::default::Default for TestTest123ResultRecv {
fn default() -> Self {
TestTest123ResultRecv::Ok(::std::default::Default::default())
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub enum TestTest123ResultRecv {
Ok(()),
}
impl ::pilota::thrift::Message for TestTest123ResultRecv {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ResultRecv",
})?;
match self {
TestTest123ResultRecv::Ok(value) => {}
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut ret = None;
__protocol.read_struct_begin()?;
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
}
__protocol.read_field_end()?;
__protocol.read_struct_end()?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
}
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut ret = None;
__protocol.read_struct_begin().await?;
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
}
__protocol.read_field_end().await?;
__protocol.read_struct_end().await?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
}
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ResultRecv",
}) + match self {
TestTest123ResultRecv::Ok(value) => 0,
} + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
)]
#[serde(transparent)]
#[derive(Clone, PartialEq, Copy)]
#[repr(transparent)]
pub struct Index(i32);
impl Index {
pub const A: Self = Self(0);
pub const B: Self = Self(1);
pub fn inner(&self) -> i32 {
self.0
}
pub fn to_string(&self) -> ::std::string::String {
match self {
Self(0) => ::std::string::String::from("A"),
Self(1) => ::std::string::String::from("B"),
Self(val) => val.to_string(),
}
}
pub fn try_from_i32(value: i32) -> ::std::option::Option<Self> {
match value {
0 => Some(Self::A),
1 => Some(Self::B),
_ => None,
}
}
}
impl ::std::convert::From<i32> for Index {
fn from(value: i32) -> Self {
Self(value)
}
}
impl ::std::convert::From<Index> for i32 {
fn from(value: Index) -> i32 {
value.0
}
}
impl ::pilota::thrift::Message for Index {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_i32(self.inner())?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let value = __protocol.read_i32()?;
::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
|err| {
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
format!("invalid enum value for Index, value: {}", value),
)
},
)?)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let value = __protocol.read_i32().await?;
::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
|err| {
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
format!("invalid enum value for Index, value: {}", value),
)
},
)?)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.i32_len(self.inner())
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct ObjReq {
pub _unknown_fields: ::pilota::BytesVec,
}
impl ::pilota::thrift::Message for ObjReq {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier { name: "ObjReq" };
__protocol.write_struct_begin(&struct_ident)?;
for bytes in self._unknown_fields.list.iter() {
__protocol.write_bytes_without_len(bytes.clone());
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut __pilota_fields_num = 0;
let mut _unknown_fields = ::pilota::BytesVec::new();
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
if __pilota_fields_num == 0 {
let __pilota_remaining = __protocol.buf().remaining();
_unknown_fields
.push_back(__protocol.get_bytes(None, __pilota_remaining - 2)?);
break;
}
let mut __pilota_offset = 0;
let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__pilota_offset += __protocol.field_stop_len();
break;
} else {
__pilota_offset +=
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__pilota_offset += __protocol.skip(field_ident.field_type)?;
_unknown_fields.push_back(
__protocol
.get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
);
}
}
__protocol.read_field_end()?;
__pilota_offset += __protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `ObjReq` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self { _unknown_fields };
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `ObjReq` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {
_unknown_fields: ::pilota::BytesVec::new(),
};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "ObjReq" })
+ self._unknown_fields.size()
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct TestTestExceptionArgsSend {
pub req: ObjReq,
}
impl ::pilota::thrift::Message for TestTestExceptionArgsSend {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionArgsSend",
};
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut var_1 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type == ::pilota::thrift::TType::Struct =>
{
var_1 = Some(::pilota::thrift::Message::decode(__protocol)?);
}
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
__protocol.read_field_end()?;
__protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!("decode struct `TestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field req is required".to_string(),
));
};
let data = Self { req: var_1 };
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut var_1 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type
== ::pilota::thrift::TType::Struct =>
{
var_1 = Some(
<ObjReq as ::pilota::thrift::Message>::decode_async(
__protocol,
)
.await?,
);
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!("decode struct `TestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field req is required".to_string(),
),
);
};
let data = Self { req: var_1 };
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionArgsSend",
}) + __protocol.struct_field_len(Some(1), &self.req)
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
impl ::std::default::Default for TestTest123ResultSend {
fn default() -> Self {
TestTest123ResultSend::Ok(::std::default::Default::default())
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub enum TestTest123ResultSend {
Ok(()),
}
impl ::pilota::thrift::Message for TestTest123ResultSend {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ResultSend",
})?;
match self {
TestTest123ResultSend::Ok(value) => {}
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut ret = None;
__protocol.read_struct_begin()?;
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
}
__protocol.read_field_end()?;
__protocol.read_struct_end()?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
}
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut ret = None;
__protocol.read_struct_begin().await?;
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
}
__protocol.read_field_end().await?;
__protocol.read_struct_end().await?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
}
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ResultSend",
}) + match self {
TestTest123ResultSend::Ok(value) => 0,
} + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct Td(pub ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>);
impl ::std::ops::Deref for Td {
type Target = ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>> for Td {
fn from(v: ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>) -> Self {
Self(v)
}
}
impl ::pilota::thrift::Message for Td {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_list(
::pilota::thrift::TType::List,
&(&**self),
|__protocol, val| {
__protocol.write_list(
::pilota::thrift::TType::Binary,
&val,
|__protocol, val| {
__protocol.write_faststr((val).clone())?;
::std::result::Result::Ok(())
},
)?;
::std::result::Result::Ok(())
},
)?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
::std::result::Result::Ok(Td(unsafe {
let list_ident = __protocol.read_list_begin()?;
let mut val: ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>> =
::std::vec::Vec::with_capacity(list_ident.size);
for i in 0..list_ident.size {
val.as_mut_ptr().offset(i as isize).write(unsafe {
let list_ident = __protocol.read_list_begin()?;
let mut val: ::std::vec::Vec<::pilota::FastStr> =
::std::vec::Vec::with_capacity(list_ident.size);
for i in 0..list_ident.size {
val.as_mut_ptr()
.offset(i as isize)
.write(__protocol.read_faststr()?);
}
val.set_len(list_ident.size);
__protocol.read_list_end()?;
val
});
}
val.set_len(list_ident.size);
__protocol.read_list_end()?;
val
}))
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
::std::result::Result::Ok(Td({
let list_ident = __protocol.read_list_begin().await?;
let mut val = ::std::vec::Vec::with_capacity(list_ident.size);
for _ in 0..list_ident.size {
val.push({
let list_ident = __protocol.read_list_begin().await?;
let mut val = ::std::vec::Vec::with_capacity(list_ident.size);
for _ in 0..list_ident.size {
val.push(__protocol.read_faststr().await?);
}
__protocol.read_list_end().await?;
val
});
}
__protocol.read_list_end().await?;
val
}))
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.list_len(::pilota::thrift::TType::List, &**self, |__protocol, el| {
__protocol.list_len(::pilota::thrift::TType::Binary, el, |__protocol, el| {
__protocol.faststr_len(el)
})
})
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct TestTestExceptionArgsRecv {
pub req: ObjReq,
}
impl ::pilota::thrift::Message for TestTestExceptionArgsRecv {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionArgsRecv",
};
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut var_1 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type == ::pilota::thrift::TType::Struct =>
{
var_1 = Some(::pilota::thrift::Message::decode(__protocol)?);
}
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
__protocol.read_field_end()?;
__protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field req is required".to_string(),
));
};
let data = Self { req: var_1 };
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut var_1 = None;
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
Some(1)
if field_ident.field_type
== ::pilota::thrift::TType::Struct =>
{
var_1 = Some(
<ObjReq as ::pilota::thrift::Message>::decode_async(
__protocol,
)
.await?,
);
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let Some(var_1) = var_1 else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"field req is required".to_string(),
),
);
};
let data = Self { req: var_1 };
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionArgsRecv",
}) + __protocol.struct_field_len(Some(1), &self.req)
+ __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
impl ::std::default::Default for TestTestExceptionResultSend {
fn default() -> Self {
TestTestExceptionResultSend::Ok(::std::default::Default::default())
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub enum TestTestExceptionResultSend {
Ok(ObjReq),
StException(StException),
}
impl ::pilota::thrift::Message for TestTestExceptionResultSend {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionResultSend",
})?;
match self {
TestTestExceptionResultSend::Ok(value) => {
__protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
}
TestTestExceptionResultSend::StException(value) => {
__protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
}
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut ret = None;
__protocol.read_struct_begin()?;
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
match field_ident.id {
Some(0) => {
if ret.is_none() {
let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
__protocol.struct_len(&field_ident);
ret = Some(TestTestExceptionResultSend::Ok(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
Some(1) => {
if ret.is_none() {
let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
__protocol.struct_len(&field_ident);
ret = Some(TestTestExceptionResultSend::StException(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
}
__protocol.read_field_end()?;
__protocol.read_struct_end()?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received empty union from remote Message",
))
}
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut ret = None;
__protocol.read_struct_begin().await?;
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
match field_ident.id {
Some(0) => {
if ret.is_none() {
let field_ident =
<ObjReq as ::pilota::thrift::Message>::decode_async(
__protocol,
)
.await?;
ret = Some(TestTestExceptionResultSend::Ok(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
Some(1) => {
if ret.is_none() {
let field_ident =
<StException as ::pilota::thrift::Message>::decode_async(
__protocol,
)
.await?;
ret =
Some(TestTestExceptionResultSend::StException(field_ident));
} else {
return ::std::result::Result::Err(
::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received multiple fields for union from remote Message",
),
);
}
}
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
}
__protocol.read_field_end().await?;
__protocol.read_struct_end().await?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
::pilota::thrift::ProtocolExceptionKind::InvalidData,
"received empty union from remote Message",
))
}
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTestExceptionResultSend",
}) + match self {
TestTestExceptionResultSend::Ok(value) => {
__protocol.struct_field_len(Some(0), value)
}
TestTestExceptionResultSend::StException(value) => {
__protocol.struct_field_len(Some(1), value)
}
} + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
pub static TEST_MAP: ::std::sync::LazyLock<::pilota::AHashMap<Index, &'static str>> =
::std::sync::LazyLock::new(|| {
let mut map = ::pilota::AHashMap::with_capacity(2);
map.insert(Index::A, "hello");
map.insert(Index::B, "world");
map
});
}
pub mod void {
pub trait Test {}
impl ::std::default::Default for TestTest123ResultRecv {
fn default() -> Self {
TestTest123ResultRecv::Ok(::std::default::Default::default())
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub enum TestTest123ResultRecv {
Ok(()),
}
impl ::pilota::thrift::Message for TestTest123ResultRecv {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ResultRecv",
})?;
match self {
TestTest123ResultRecv::Ok(value) => {}
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut ret = None;
__protocol.read_struct_begin()?;
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
}
__protocol.read_field_end()?;
__protocol.read_struct_end()?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
}
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut ret = None;
__protocol.read_struct_begin().await?;
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
}
__protocol.read_field_end().await?;
__protocol.read_struct_end().await?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
}
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ResultRecv",
}) + match self {
TestTest123ResultRecv::Ok(value) => 0,
} + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
impl ::std::default::Default for TestTest123ResultSend {
fn default() -> Self {
TestTest123ResultSend::Ok(::std::default::Default::default())
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub enum TestTest123ResultSend {
Ok(()),
}
impl ::pilota::thrift::Message for TestTest123ResultSend {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
__protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ResultSend",
})?;
match self {
TestTest123ResultSend::Ok(value) => {}
}
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut ret = None;
__protocol.read_struct_begin()?;
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
}
__protocol.read_field_end()?;
__protocol.read_struct_end()?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
}
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut ret = None;
__protocol.read_struct_begin().await?;
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
}
__protocol.read_field_end().await?;
__protocol.read_struct_end().await?;
if let Some(ret) = ret {
::std::result::Result::Ok(ret)
} else {
::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
}
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ResultSend",
}) + match self {
TestTest123ResultSend::Ok(value) => 0,
} + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct TestTest123ArgsSend {}
impl ::pilota::thrift::Message for TestTest123ArgsSend {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier {
name: "TestTest123ArgsSend",
};
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
__protocol.read_field_end()?;
__protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self {};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ArgsSend",
}) + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
#[derive(
PartialOrd,
Hash,
Eq,
Ord,
Debug,
Default,
::pilota::serde::Serialize,
::pilota::serde::Deserialize,
Clone,
PartialEq,
)]
pub struct TestTest123ArgsRecv {}
impl ::pilota::thrift::Message for TestTest123ArgsRecv {
fn encode<T: ::pilota::thrift::TOutputProtocol>(
&self,
__protocol: &mut T,
) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::thrift::TOutputProtocolExt;
let struct_ident = ::pilota::thrift::TStructIdentifier {
name: "TestTest123ArgsRecv",
};
__protocol.write_struct_begin(&struct_ident)?;
__protocol.write_field_stop()?;
__protocol.write_struct_end()?;
::std::result::Result::Ok(())
}
fn decode<T: ::pilota::thrift::TInputProtocol>(
__protocol: &mut T,
) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
#[allow(unused_imports)]
use ::pilota::{Buf, thrift::TLengthProtocolExt};
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin()?;
if let ::std::result::Result::Err(mut err) = (|| {
loop {
let field_ident = __protocol.read_field_begin()?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
__protocol.field_stop_len();
break;
} else {
__protocol.field_begin_len(field_ident.field_type, field_ident.id);
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type)?;
}
}
__protocol.read_field_end()?;
__protocol.field_end_len();
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
})() {
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!(
"decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
field_id
));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end()?;
let data = Self {};
::std::result::Result::Ok(data)
}
fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
__protocol: &'a mut T,
) -> ::std::pin::Pin<
::std::boxed::Box<
dyn ::std::future::Future<
Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
> + Send
+ 'a,
>,
> {
::std::boxed::Box::pin(async move {
let mut __pilota_decoding_field_id = None;
__protocol.read_struct_begin().await?;
if let ::std::result::Result::Err(mut err) = async {
loop {
let field_ident = __protocol.read_field_begin().await?;
if field_ident.field_type == ::pilota::thrift::TType::Stop {
break;
} else {
}
__pilota_decoding_field_id = field_ident.id;
match field_ident.id {
_ => {
__protocol.skip(field_ident.field_type).await?;
}
}
__protocol.read_field_end().await?;
}
::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
}
.await
{
if let Some(field_id) = __pilota_decoding_field_id {
err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
}
return ::std::result::Result::Err(err);
};
__protocol.read_struct_end().await?;
let data = Self {};
::std::result::Result::Ok(data)
})
}
fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
#[allow(unused_imports)]
use ::pilota::thrift::TLengthProtocolExt;
__protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
name: "TestTest123ArgsRecv",
}) + __protocol.field_stop_len()
+ __protocol.struct_end_len()
}
}
}
}