#[allow(
unused,
non_snake_case,
non_camel_case_types,
clippy::all,
unreachable_pub,
reason = "generated by protoc-gen-pbrs"
)]
mod __gen {
#![allow(
unused,
non_snake_case,
non_camel_case_types,
clippy::all,
unsafe_code,
unreachable_pub,
reason = "generated by protoc-gen-pbrs"
)]
use pbrs::prelude::*;
use pbrs::UnknownFields;
use pbrs::{
Enum, Map, MapMut, MapView, ParseError, ProtoBytes, ProtoString, Repeated, RepeatedMut,
RepeatedView, SerializeError, UnknownEnumValue,
};
fn generated_pool() -> std::sync::Arc<pbrs::DescriptorPool> {
pbrs::gencode::conformance_pool()
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct ForeignEnumEditionUnstable(i32);
#[allow(non_upper_case_globals, reason = "protobuf enum names")]
impl ForeignEnumEditionUnstable {
pub const ForeignFoo: ForeignEnumEditionUnstable = ForeignEnumEditionUnstable(0);
pub const ForeignBar: ForeignEnumEditionUnstable = ForeignEnumEditionUnstable(1);
pub const ForeignBaz: ForeignEnumEditionUnstable = ForeignEnumEditionUnstable(2);
fn constant_name(self) -> Option<&'static str> {
#[allow(unreachable_patterns, reason = "open enums")]
Some(match self.0 {
0 => "ForeignFoo",
1 => "ForeignBar",
2 => "ForeignBaz",
_ => return None,
})
}
}
impl From<ForeignEnumEditionUnstable> for i32 {
fn from(v: ForeignEnumEditionUnstable) -> i32 {
v.0
}
}
impl From<i32> for ForeignEnumEditionUnstable {
fn from(val: i32) -> Self {
Self(val)
}
}
impl Default for ForeignEnumEditionUnstable {
fn default() -> Self {
Self(0)
}
}
impl std::fmt::Debug for ForeignEnumEditionUnstable {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(n) = self.constant_name() {
write!(f, "ForeignEnumEditionUnstable::{n}")
} else {
write!(f, "ForeignEnumEditionUnstable::from({})", self.0)
}
}
}
impl pbrs::__internal::SealedInternal for ForeignEnumEditionUnstable {}
impl pbrs::Proxied for ForeignEnumEditionUnstable {
type View<'msg> = ForeignEnumEditionUnstable;
}
impl pbrs::AsView for ForeignEnumEditionUnstable {
type Proxied = Self;
fn as_view(&self) -> Self {
*self
}
}
impl<'msg> pbrs::IntoView<'msg> for ForeignEnumEditionUnstable {
fn into_view<'shorter>(self) -> Self
where
'msg: 'shorter,
{
self
}
}
impl Enum for ForeignEnumEditionUnstable {
const NAME: &'static str = "ForeignEnumEditionUnstable";
fn is_known(value: i32) -> bool {
matches!(value, 0 | 1 | 2)
}
}
#[derive(Clone, Debug)]
pub struct ComplexMessage {
d: Option<i32>,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for ComplexMessage {
fn eq(&self, other: &Self) -> bool {
if self.d != other.d {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for ComplexMessage {}
impl Default for ComplexMessage {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl ComplexMessage {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str =
"protobuf_test_messages.edition_unstable.ComplexMessage";
pub fn has_d(&self) -> bool {
self.d.is_some()
}
pub fn d(&self) -> i32 {
self.d.unwrap_or(0)
}
pub fn d_opt(&self) -> Option<i32> {
self.d.map(|v| v)
}
pub fn set_d(&mut self, v: i32) {
self.cached_size.dirty();
self.d = Some(v);
}
pub fn clear_d(&mut self) {
self.cached_size.dirty();
self.d = None;
}
#[inline(always)]
fn check_required(&self) -> Result<(), ParseError> {
Ok(())
}
fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
if data.is_empty() {
return self.check_required();
}
let mut pos = 0;
let mut wire = None;
self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
}
fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
if data.is_empty() {
return Ok(());
}
let mut pos = 0;
let mut wire = None;
self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
}
fn merge_group(
&mut self,
data: &[u8],
wire: &mut Option<pbrs::rt::Wire>,
pos: &mut usize,
num: u32,
depth: u32,
) -> Result<(), ParseError> {
self.merge_inner(data, wire, pos, depth, false, Some(num))
}
fn merge_inner(
&mut self,
data: &[u8],
wire: &mut Option<pbrs::rt::Wire>,
pos: &mut usize,
depth: u32,
enforce: bool,
until: Option<u32>,
) -> Result<(), ParseError> {
if depth > pbrs::RECURSION_LIMIT {
return Err(ParseError::new("recursion limit exceeded"));
}
let _ = enforce;
self.cached_size.dirty();
while *pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, pos)?;
if let Some(g) = until {
if w == pbrs::rt::WIRE_EGROUP {
if n != g {
return Err(ParseError::new("mismatched end-group"));
}
return Ok(());
}
}
match n {
1 => match w {
pbrs::rt::WIRE_I32 => {
self.d = Some(pbrs::rt::read_fixed32(data, pos)? as i32);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
}
}
if until.is_some() {
return Err(ParseError::new("truncated group"));
}
if enforce {
self.check_required()?;
}
Ok(())
}
fn validate_inner(
wire: &pbrs::rt::Wire,
pos: &mut usize,
depth: u32,
) -> Result<(), ParseError> {
Self::validate_until(wire, pos, depth, None)
}
fn validate_until(
wire: &pbrs::rt::Wire,
pos: &mut usize,
depth: u32,
until: Option<u32>,
) -> Result<(), ParseError> {
if depth > pbrs::RECURSION_LIMIT {
return Err(ParseError::new("recursion limit exceeded"));
}
let data = wire.as_slice();
while *pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, pos)?;
if let Some(g) = until {
if w == pbrs::rt::WIRE_EGROUP {
if n != g {
return Err(ParseError::new("mismatched end-group"));
}
return Ok(());
}
}
match n {
1 => match w {
pbrs::rt::WIRE_I32 => {
let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
_ => pbrs::rt::skip_field(data, pos, w)?,
}
}
if until.is_some() {
return Err(ParseError::new("truncated group"));
}
Ok(())
}
fn compute_size(&self) -> u64 {
if let Some(n) = self.cached_size.get() {
return n;
}
let mut n = self.unknown.encoded_len();
if let Some(v) = self.d {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32) + 4;
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if let Some(v) = self.d {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
(out).extend_from_slice(&((v) as u32).to_le_bytes());
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("json"))?;
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.ComplexMessage")
.ok_or_else(|| SerializeError::new("missing desc"))?;
pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
.map_err(|_| SerializeError::new("json"))?
.to_json()
}
pub fn from_json(json: &str) -> Result<Self, ParseError> {
Self::from_json_ignore(json, false)
}
pub fn from_json_ignore(json: &str, ignore: bool) -> Result<Self, ParseError> {
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.ComplexMessage")
.ok_or_else(|| ParseError::owned("missing desc".into()))?;
let d = pbrs::DynamicMessage::from_json_with_pool(desc, Some(pool), json, ignore)?;
let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
<Self as pbrs::Parse>::parse(&b)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.ComplexMessage")
.ok_or_else(|| SerializeError::new("missing desc"))?;
pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
.map_err(|_| SerializeError::new("text"))?
.to_text()
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.ComplexMessage")
.ok_or_else(|| SerializeError::new("missing desc"))?;
pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
.map_err(|_| SerializeError::new("text"))?
.to_text_with_unknown()
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.ComplexMessage")
.ok_or_else(|| ParseError::owned("missing desc".into()))?;
let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
<Self as pbrs::Parse>::parse(&b)
}
}
pbrs::impl_typed_message!(ComplexMessage, ComplexMessageView, ComplexMessageMut);
#[derive(Clone, Debug)]
pub struct ForeignMessageEditionUnstable {
c: Option<i32>,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for ForeignMessageEditionUnstable {
fn eq(&self, other: &Self) -> bool {
if self.c != other.c {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for ForeignMessageEditionUnstable {}
impl Default for ForeignMessageEditionUnstable {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl ForeignMessageEditionUnstable {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str =
"protobuf_test_messages.edition_unstable.ForeignMessageEditionUnstable";
pub fn has_c(&self) -> bool {
self.c.is_some()
}
pub fn c(&self) -> i32 {
self.c.unwrap_or(0)
}
pub fn c_opt(&self) -> Option<i32> {
self.c.map(|v| v)
}
pub fn set_c(&mut self, v: i32) {
self.cached_size.dirty();
self.c = Some(v);
}
pub fn clear_c(&mut self) {
self.cached_size.dirty();
self.c = None;
}
#[inline(always)]
fn check_required(&self) -> Result<(), ParseError> {
Ok(())
}
fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
if data.is_empty() {
return self.check_required();
}
let mut pos = 0;
let mut wire = None;
self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
}
fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
if data.is_empty() {
return Ok(());
}
let mut pos = 0;
let mut wire = None;
self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
}
fn merge_group(
&mut self,
data: &[u8],
wire: &mut Option<pbrs::rt::Wire>,
pos: &mut usize,
num: u32,
depth: u32,
) -> Result<(), ParseError> {
self.merge_inner(data, wire, pos, depth, false, Some(num))
}
fn merge_inner(
&mut self,
data: &[u8],
wire: &mut Option<pbrs::rt::Wire>,
pos: &mut usize,
depth: u32,
enforce: bool,
until: Option<u32>,
) -> Result<(), ParseError> {
if depth > pbrs::RECURSION_LIMIT {
return Err(ParseError::new("recursion limit exceeded"));
}
let _ = enforce;
self.cached_size.dirty();
while *pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, pos)?;
if let Some(g) = until {
if w == pbrs::rt::WIRE_EGROUP {
if n != g {
return Err(ParseError::new("mismatched end-group"));
}
return Ok(());
}
}
match n {
1 => match w {
pbrs::rt::WIRE_I32 => {
self.c = Some(pbrs::rt::read_fixed32(data, pos)? as i32);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
}
}
if until.is_some() {
return Err(ParseError::new("truncated group"));
}
if enforce {
self.check_required()?;
}
Ok(())
}
fn validate_inner(
wire: &pbrs::rt::Wire,
pos: &mut usize,
depth: u32,
) -> Result<(), ParseError> {
Self::validate_until(wire, pos, depth, None)
}
fn validate_until(
wire: &pbrs::rt::Wire,
pos: &mut usize,
depth: u32,
until: Option<u32>,
) -> Result<(), ParseError> {
if depth > pbrs::RECURSION_LIMIT {
return Err(ParseError::new("recursion limit exceeded"));
}
let data = wire.as_slice();
while *pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, pos)?;
if let Some(g) = until {
if w == pbrs::rt::WIRE_EGROUP {
if n != g {
return Err(ParseError::new("mismatched end-group"));
}
return Ok(());
}
}
match n {
1 => match w {
pbrs::rt::WIRE_I32 => {
let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
_ => pbrs::rt::skip_field(data, pos, w)?,
}
}
if until.is_some() {
return Err(ParseError::new("truncated group"));
}
Ok(())
}
fn compute_size(&self) -> u64 {
if let Some(n) = self.cached_size.get() {
return n;
}
let mut n = self.unknown.encoded_len();
if let Some(v) = self.c {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32) + 4;
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if let Some(v) = self.c {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
(out).extend_from_slice(&((v) as u32).to_le_bytes());
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("json"))?;
let pool = generated_pool();
let desc = pool
.get_message(
"protobuf_test_messages.edition_unstable.ForeignMessageEditionUnstable",
)
.ok_or_else(|| SerializeError::new("missing desc"))?;
pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
.map_err(|_| SerializeError::new("json"))?
.to_json()
}
pub fn from_json(json: &str) -> Result<Self, ParseError> {
Self::from_json_ignore(json, false)
}
pub fn from_json_ignore(json: &str, ignore: bool) -> Result<Self, ParseError> {
let pool = generated_pool();
let desc = pool
.get_message(
"protobuf_test_messages.edition_unstable.ForeignMessageEditionUnstable",
)
.ok_or_else(|| ParseError::owned("missing desc".into()))?;
let d = pbrs::DynamicMessage::from_json_with_pool(desc, Some(pool), json, ignore)?;
let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
<Self as pbrs::Parse>::parse(&b)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
let pool = generated_pool();
let desc = pool
.get_message(
"protobuf_test_messages.edition_unstable.ForeignMessageEditionUnstable",
)
.ok_or_else(|| SerializeError::new("missing desc"))?;
pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
.map_err(|_| SerializeError::new("text"))?
.to_text()
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
let pool = generated_pool();
let desc = pool
.get_message(
"protobuf_test_messages.edition_unstable.ForeignMessageEditionUnstable",
)
.ok_or_else(|| SerializeError::new("missing desc"))?;
pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
.map_err(|_| SerializeError::new("text"))?
.to_text_with_unknown()
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
let pool = generated_pool();
let desc = pool
.get_message(
"protobuf_test_messages.edition_unstable.ForeignMessageEditionUnstable",
)
.ok_or_else(|| ParseError::owned("missing desc".into()))?;
let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
<Self as pbrs::Parse>::parse(&b)
}
}
pbrs::impl_typed_message!(
ForeignMessageEditionUnstable,
ForeignMessageEditionUnstableView,
ForeignMessageEditionUnstableMut
);
#[derive(Clone, Debug)]
pub struct TestAllTypesEditionUnstable {
optional_int32: Option<i32>,
optional_foreign_message: pbrs::rt::LazyMsg<ForeignMessageEditionUnstable>,
optional_foreign_enum: Option<i32>,
recursive_message: pbrs::rt::LazyMsg<TestAllTypesEditionUnstable>,
repeated_int32: pbrs::rt::PackedSfx32,
repeated_foreign_message: Repeated<ForeignMessageEditionUnstable>,
repeated_foreign_enum: pbrs::rt::PackedI32,
map_int32_int32: Map<i32, i32>,
map_bool_bool: Map<bool, bool>,
map_string_string: Map<pbrs::rt::LazyStr, pbrs::rt::LazyStr>,
map_string_foreign_message: Map<pbrs::rt::LazyStr, ForeignMessageEditionUnstable>,
map_string_foreign_enum: Map<pbrs::rt::LazyStr, i32>,
optional_bytes: Option<Box<pbrs::rt::LazyBytes>>,
repeated_bytes: Repeated<pbrs::rt::LazyBytes>,
map_string_bytes: Map<pbrs::rt::LazyStr, pbrs::rt::LazyBytes>,
extension_int32: Option<i32>,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for TestAllTypesEditionUnstable {
fn eq(&self, other: &Self) -> bool {
if self.optional_int32 != other.optional_int32 {
return false;
}
if self.optional_foreign_message != other.optional_foreign_message {
return false;
}
if self.optional_foreign_enum != other.optional_foreign_enum {
return false;
}
if self.recursive_message != other.recursive_message {
return false;
}
if self.repeated_int32 != other.repeated_int32 {
return false;
}
if self.repeated_foreign_message != other.repeated_foreign_message {
return false;
}
if self.repeated_foreign_enum != other.repeated_foreign_enum {
return false;
}
if self.map_int32_int32 != other.map_int32_int32 {
return false;
}
if self.map_bool_bool != other.map_bool_bool {
return false;
}
if self.map_string_string != other.map_string_string {
return false;
}
if self.map_string_foreign_message != other.map_string_foreign_message {
return false;
}
if self.map_string_foreign_enum != other.map_string_foreign_enum {
return false;
}
if self.optional_bytes != other.optional_bytes {
return false;
}
if self.repeated_bytes != other.repeated_bytes {
return false;
}
if self.map_string_bytes != other.map_string_bytes {
return false;
}
if self.extension_int32 != other.extension_int32 {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for TestAllTypesEditionUnstable {}
impl Default for TestAllTypesEditionUnstable {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl TestAllTypesEditionUnstable {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str =
"protobuf_test_messages.edition_unstable.TestAllTypesEditionUnstable";
pub fn has_optional_int32(&self) -> bool {
self.optional_int32.is_some()
}
pub fn optional_int32(&self) -> i32 {
self.optional_int32.unwrap_or(0)
}
pub fn optional_int32_opt(&self) -> Option<i32> {
self.optional_int32.map(|v| v)
}
pub fn set_optional_int32(&mut self, v: i32) {
self.cached_size.dirty();
self.optional_int32 = Some(v);
}
pub fn clear_optional_int32(&mut self) {
self.cached_size.dirty();
self.optional_int32 = None;
}
pub fn has_optional_foreign_message(&self) -> bool {
self.optional_foreign_message.is_some()
}
pub fn optional_foreign_message(&self) -> &ForeignMessageEditionUnstable {
self.optional_foreign_message
.as_deref()
.unwrap_or(pbrs::gen_support::default_instance_of())
}
pub fn optional_foreign_message_opt(&self) -> Option<&ForeignMessageEditionUnstable> {
self.optional_foreign_message.as_deref()
}
pub fn optional_foreign_message_view(&self) -> ForeignMessageEditionUnstableView<'_> {
ForeignMessageEditionUnstableView(self.optional_foreign_message())
}
pub fn set_optional_foreign_message(&mut self, v: ForeignMessageEditionUnstable) {
self.cached_size.dirty();
self.optional_foreign_message = pbrs::rt::LazyMsg::from_owned(v);
}
pub fn optional_foreign_message_mut(&mut self) -> &mut ForeignMessageEditionUnstable {
self.cached_size.dirty();
self.optional_foreign_message.get_or_insert()
}
pub fn clear_optional_foreign_message(&mut self) {
self.cached_size.dirty();
self.optional_foreign_message.clear();
}
pub fn has_optional_foreign_enum(&self) -> bool {
self.optional_foreign_enum.is_some()
}
pub fn optional_foreign_enum(&self) -> ForeignEnumEditionUnstable {
ForeignEnumEditionUnstable(self.optional_foreign_enum.unwrap_or(0))
}
pub fn optional_foreign_enum_opt(&self) -> Option<ForeignEnumEditionUnstable> {
self.optional_foreign_enum
.map(|v| ForeignEnumEditionUnstable(v))
}
pub fn set_optional_foreign_enum(&mut self, v: impl Into<i32>) {
self.cached_size.dirty();
self.optional_foreign_enum = Some(v.into());
}
pub fn clear_optional_foreign_enum(&mut self) {
self.cached_size.dirty();
self.optional_foreign_enum = None;
}
pub fn has_recursive_message(&self) -> bool {
self.recursive_message.is_some()
}
pub fn recursive_message(&self) -> &TestAllTypesEditionUnstable {
self.recursive_message
.as_deref()
.unwrap_or(pbrs::gen_support::default_instance_of())
}
pub fn recursive_message_opt(&self) -> Option<&TestAllTypesEditionUnstable> {
self.recursive_message.as_deref()
}
pub fn recursive_message_view(&self) -> TestAllTypesEditionUnstableView<'_> {
TestAllTypesEditionUnstableView(self.recursive_message())
}
pub fn set_recursive_message(&mut self, v: TestAllTypesEditionUnstable) {
self.cached_size.dirty();
self.recursive_message = pbrs::rt::LazyMsg::from_owned(v);
}
pub fn recursive_message_mut(&mut self) -> &mut TestAllTypesEditionUnstable {
self.cached_size.dirty();
self.recursive_message.get_or_insert()
}
pub fn clear_recursive_message(&mut self) {
self.cached_size.dirty();
self.recursive_message.clear();
}
pub fn repeated_int32(&self) -> RepeatedView<'_, i32> {
self.repeated_int32.as_view()
}
pub fn repeated_int32_mut(&mut self) -> RepeatedMut<'_, i32> {
self.cached_size.dirty();
self.repeated_int32.as_mut()
}
pub fn set_repeated_int32(&mut self, v: impl IntoIterator<Item = i32>) {
self.cached_size.dirty();
self.repeated_int32 = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
}
pub fn repeated_foreign_message(&self) -> RepeatedView<'_, ForeignMessageEditionUnstable> {
self.repeated_foreign_message.as_view()
}
pub fn repeated_foreign_message_mut(
&mut self,
) -> RepeatedMut<'_, ForeignMessageEditionUnstable> {
self.cached_size.dirty();
self.repeated_foreign_message.as_mut()
}
pub fn set_repeated_foreign_message(
&mut self,
v: impl IntoIterator<Item = ForeignMessageEditionUnstable>,
) {
self.cached_size.dirty();
self.repeated_foreign_message = v.into_iter().collect();
}
pub fn repeated_foreign_enum(&self) -> RepeatedView<'_, i32> {
self.repeated_foreign_enum.as_view()
}
pub fn repeated_foreign_enum_mut(&mut self) -> RepeatedMut<'_, i32> {
self.cached_size.dirty();
self.repeated_foreign_enum.as_mut()
}
pub fn set_repeated_foreign_enum(&mut self, v: impl IntoIterator<Item = i32>) {
self.cached_size.dirty();
self.repeated_foreign_enum = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
}
pub fn map_int32_int32(&self) -> MapView<'_, i32, i32> {
self.map_int32_int32.as_view()
}
pub fn map_int32_int32_mut(&mut self) -> MapMut<'_, i32, i32> {
self.cached_size.dirty();
self.map_int32_int32.as_mut()
}
pub fn set_map_int32_int32(&mut self, v: Map<i32, i32>) {
self.cached_size.dirty();
self.map_int32_int32 = v;
}
pub fn map_bool_bool(&self) -> MapView<'_, bool, bool> {
self.map_bool_bool.as_view()
}
pub fn map_bool_bool_mut(&mut self) -> MapMut<'_, bool, bool> {
self.cached_size.dirty();
self.map_bool_bool.as_mut()
}
pub fn set_map_bool_bool(&mut self, v: Map<bool, bool>) {
self.cached_size.dirty();
self.map_bool_bool = v;
}
pub fn map_string_string(&self) -> MapView<'_, pbrs::rt::LazyStr, pbrs::rt::LazyStr> {
self.map_string_string.as_view()
}
pub fn map_string_string_mut(
&mut self,
) -> MapMut<'_, pbrs::rt::LazyStr, pbrs::rt::LazyStr> {
self.cached_size.dirty();
self.map_string_string.as_mut()
}
pub fn set_map_string_string(&mut self, v: Map<pbrs::rt::LazyStr, pbrs::rt::LazyStr>) {
self.cached_size.dirty();
self.map_string_string = v;
}
pub fn map_string_foreign_message(
&self,
) -> MapView<'_, pbrs::rt::LazyStr, ForeignMessageEditionUnstable> {
self.map_string_foreign_message.as_view()
}
pub fn map_string_foreign_message_mut(
&mut self,
) -> MapMut<'_, pbrs::rt::LazyStr, ForeignMessageEditionUnstable> {
self.cached_size.dirty();
self.map_string_foreign_message.as_mut()
}
pub fn set_map_string_foreign_message(
&mut self,
v: Map<pbrs::rt::LazyStr, ForeignMessageEditionUnstable>,
) {
self.cached_size.dirty();
self.map_string_foreign_message = v;
}
pub fn map_string_foreign_enum(&self) -> MapView<'_, pbrs::rt::LazyStr, i32> {
self.map_string_foreign_enum.as_view()
}
pub fn map_string_foreign_enum_mut(&mut self) -> MapMut<'_, pbrs::rt::LazyStr, i32> {
self.cached_size.dirty();
self.map_string_foreign_enum.as_mut()
}
pub fn set_map_string_foreign_enum(&mut self, v: Map<pbrs::rt::LazyStr, i32>) {
self.cached_size.dirty();
self.map_string_foreign_enum = v;
}
pub fn optional_bytes(&self) -> &[u8] {
self.optional_bytes
.as_ref()
.map(|b| b.as_bytes())
.unwrap_or(b"")
}
pub fn optional_bytes_opt(&self) -> Option<&[u8]> {
self.optional_bytes.as_ref().map(|b| b.as_bytes())
}
pub fn has_optional_bytes(&self) -> bool {
self.optional_bytes.is_some()
}
pub fn set_optional_bytes(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
self.cached_size.dirty();
self.optional_bytes = Some(Box::new(pbrs::rt::LazyBytes::owned(
v.into_proxied(pbrs::__internal::Private),
)));
}
pub fn clear_optional_bytes(&mut self) {
self.cached_size.dirty();
self.optional_bytes = None;
}
pub fn repeated_bytes(&self) -> RepeatedView<'_, pbrs::rt::LazyBytes> {
self.repeated_bytes.as_view()
}
pub fn repeated_bytes_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyBytes> {
self.cached_size.dirty();
self.repeated_bytes.as_mut()
}
pub fn set_repeated_bytes(&mut self, v: impl IntoIterator<Item = pbrs::rt::LazyBytes>) {
self.cached_size.dirty();
self.repeated_bytes = v.into_iter().collect();
}
pub fn map_string_bytes(&self) -> MapView<'_, pbrs::rt::LazyStr, pbrs::rt::LazyBytes> {
self.map_string_bytes.as_view()
}
pub fn map_string_bytes_mut(
&mut self,
) -> MapMut<'_, pbrs::rt::LazyStr, pbrs::rt::LazyBytes> {
self.cached_size.dirty();
self.map_string_bytes.as_mut()
}
pub fn set_map_string_bytes(&mut self, v: Map<pbrs::rt::LazyStr, pbrs::rt::LazyBytes>) {
self.cached_size.dirty();
self.map_string_bytes = v;
}
pub fn has_extension_int32(&self) -> bool {
self.extension_int32.is_some()
}
pub fn extension_int32(&self) -> i32 {
self.extension_int32.unwrap_or(0)
}
pub fn extension_int32_opt(&self) -> Option<i32> {
self.extension_int32.map(|v| v)
}
pub fn set_extension_int32(&mut self, v: i32) {
self.cached_size.dirty();
self.extension_int32 = Some(v);
}
pub fn clear_extension_int32(&mut self) {
self.cached_size.dirty();
self.extension_int32 = None;
}
#[inline(always)]
fn check_required(&self) -> Result<(), ParseError> {
Ok(())
}
fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
if data.is_empty() {
return self.check_required();
}
let mut pos = 0;
let mut wire = None;
self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
}
fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
if data.is_empty() {
return Ok(());
}
let mut pos = 0;
let mut wire = None;
self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
}
fn merge_group(
&mut self,
data: &[u8],
wire: &mut Option<pbrs::rt::Wire>,
pos: &mut usize,
num: u32,
depth: u32,
) -> Result<(), ParseError> {
self.merge_inner(data, wire, pos, depth, false, Some(num))
}
fn merge_inner(
&mut self,
data: &[u8],
wire: &mut Option<pbrs::rt::Wire>,
pos: &mut usize,
depth: u32,
enforce: bool,
until: Option<u32>,
) -> Result<(), ParseError> {
if depth > pbrs::RECURSION_LIMIT {
return Err(ParseError::new("recursion limit exceeded"));
}
let _ = enforce;
self.cached_size.dirty();
while *pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, pos)?;
if let Some(g) = until {
if w == pbrs::rt::WIRE_EGROUP {
if n != g {
return Err(ParseError::new("mismatched end-group"));
}
return Ok(());
}
}
match n {
1 => match w {
pbrs::rt::WIRE_I32 => {
self.optional_int32 = Some(pbrs::rt::read_fixed32(data, pos)? as i32);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
2 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
if self.optional_foreign_message.is_some() {
let mut ip = 0;
let mut sw = None;
self.optional_foreign_message.get_or_insert().merge_inner(
&data[s..e],
&mut sw,
&mut ip,
depth + 1,
true,
None,
)?;
} else {
let mut ip = 0;
ForeignMessageEditionUnstable::validate_inner(
&pbrs::rt::Wire::ensure(wire, data).window(s, e),
&mut ip,
depth + 1,
)?;
self.optional_foreign_message = pbrs::rt::LazyMsg::from_wire(
pbrs::rt::Wire::ensure(wire, data).window(s, e),
);
}
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
3 => match w {
pbrs::rt::WIRE_VARINT => {
self.optional_foreign_enum =
Some(pbrs::rt::decode_varint(data, pos)? as i32);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
4 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
if self.recursive_message.is_some() {
let mut ip = 0;
let mut sw = None;
self.recursive_message.get_or_insert().merge_inner(
&data[s..e],
&mut sw,
&mut ip,
depth + 1,
true,
None,
)?;
} else {
let mut ip = 0;
TestAllTypesEditionUnstable::validate_inner(
&pbrs::rt::Wire::ensure(wire, data).window(s, e),
&mut ip,
depth + 1,
)?;
self.recursive_message = pbrs::rt::LazyMsg::from_wire(
pbrs::rt::Wire::ensure(wire, data).window(s, e),
);
}
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
5 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
self.repeated_int32
.append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
}
pbrs::rt::WIRE_I32 => {
self.repeated_int32
.push(pbrs::rt::read_fixed32(data, pos)? as i32);
let rest = data.len().saturating_sub(*pos);
if rest > 2 {
self.repeated_int32.reserve(rest / 3);
}
while *pos < data.len() {
let save = *pos;
match pbrs::rt::decode_tag(data, pos) {
Ok((n2, w2)) if n2 == 5 && w2 == pbrs::rt::WIRE_I32 => self
.repeated_int32
.push(pbrs::rt::read_fixed32(data, pos)? as i32),
Ok(_) => {
*pos = save;
break;
}
Err(e) => return Err(e),
}
}
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
6 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let rest = data.len().saturating_sub(e);
if rest > 2 {
self.repeated_foreign_message
.reserve(1 + rest / (e - s + 4).max(1));
}
let mut inner = ForeignMessageEditionUnstable::default();
let mut ip = 0;
let mut sw = None;
inner.merge_inner(
&data[s..e],
&mut sw,
&mut ip,
depth + 1,
true,
None,
)?;
self.repeated_foreign_message.push(inner);
while *pos < data.len() {
let save = *pos;
match pbrs::rt::decode_tag(data, pos) {
Ok((n2, w2)) if n2 == 6 && w2 == pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut inner = ForeignMessageEditionUnstable::default();
let mut ip = 0;
let mut sw = None;
inner.merge_inner(
&data[s..e],
&mut sw,
&mut ip,
depth + 1,
true,
None,
)?;
self.repeated_foreign_message.push(inner);
}
Ok(_) => {
*pos = save;
break;
}
Err(e) => return Err(e),
}
}
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
7 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
self.repeated_foreign_enum
.append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
}
pbrs::rt::WIRE_VARINT => {
self.repeated_foreign_enum
.push(pbrs::rt::decode_varint(data, pos)? as i32);
let rest = data.len().saturating_sub(*pos);
if rest > 2 {
self.repeated_foreign_enum.reserve(rest / 3);
}
while *pos < data.len() {
let save = *pos;
match pbrs::rt::decode_tag(data, pos) {
Ok((n2, w2)) if n2 == 7 && w2 == pbrs::rt::WIRE_VARINT => self
.repeated_foreign_enum
.push(pbrs::rt::decode_varint(data, pos)? as i32),
Ok(_) => {
*pos = save;
break;
}
Err(e) => return Err(e),
}
}
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
8 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let (kk, vv) =
decode_map_entry_TestAllTypesEditionUnstable_map_int32_int32_8(
&pbrs::rt::Wire::ensure(wire, data).window(s, e),
depth + 1,
)?;
self.map_int32_int32.push_entry(kk, vv);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
9 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let (kk, vv) =
decode_map_entry_TestAllTypesEditionUnstable_map_bool_bool_9(
&pbrs::rt::Wire::ensure(wire, data).window(s, e),
depth + 1,
)?;
self.map_bool_bool.push_entry(kk, vv);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
10 => {
match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let (kk, vv) = decode_map_entry_TestAllTypesEditionUnstable_map_string_string_10(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
self.map_string_string.push_entry(kk, vv);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
}
}
11 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let (kk, vv) = decode_map_entry_TestAllTypesEditionUnstable_map_string_foreign_message_11(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
self.map_string_foreign_message.push_entry(kk, vv);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
12 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let (kk, vv) = decode_map_entry_TestAllTypesEditionUnstable_map_string_foreign_enum_12(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
self.map_string_foreign_enum.push_entry(kk, vv);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
13 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
self.optional_bytes = Some(Box::new(pbrs::rt::LazyBytes::from_parse_span(wire, data, s, e)));
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
14 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
self.repeated_bytes.push(pbrs::rt::LazyBytes::from_parse_span(wire, data, s, e));
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
15 => {
match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let (kk, vv) = decode_map_entry_TestAllTypesEditionUnstable_map_string_bytes_15(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
self.map_string_bytes.push_entry(kk, vv);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
}
}
120 => match w {
pbrs::rt::WIRE_I32 => {
self.extension_int32 = Some(pbrs::rt::read_fixed32(data, pos)? as i32);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
}
}
if until.is_some() {
return Err(ParseError::new("truncated group"));
}
if enforce {
self.check_required()?;
}
Ok(())
}
fn validate_inner(
wire: &pbrs::rt::Wire,
pos: &mut usize,
depth: u32,
) -> Result<(), ParseError> {
Self::validate_until(wire, pos, depth, None)
}
fn validate_until(
wire: &pbrs::rt::Wire,
pos: &mut usize,
depth: u32,
until: Option<u32>,
) -> Result<(), ParseError> {
if depth > pbrs::RECURSION_LIMIT {
return Err(ParseError::new("recursion limit exceeded"));
}
let data = wire.as_slice();
while *pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, pos)?;
if let Some(g) = until {
if w == pbrs::rt::WIRE_EGROUP {
if n != g {
return Err(ParseError::new("mismatched end-group"));
}
return Ok(());
}
}
match n {
1 => match w {
pbrs::rt::WIRE_I32 => {
let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
2 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
ForeignMessageEditionUnstable::validate_inner(
&wire.window(s, e),
&mut ip,
depth + 1,
)?;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
3 => match w {
pbrs::rt::WIRE_VARINT => {
let _ = pbrs::rt::decode_varint(data, pos)? as i32;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
4 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
TestAllTypesEditionUnstable::validate_inner(
&wire.window(s, e),
&mut ip,
depth + 1,
)?;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
5 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
pbrs::rt::PackedSfx32::validate_bytes(&data[s..e])?;
}
pbrs::rt::WIRE_I32 => {
let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
6 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
ForeignMessageEditionUnstable::validate_inner(
&wire.window(s, e),
&mut ip,
depth + 1,
)?;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
7 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
}
pbrs::rt::WIRE_VARINT => {
let _ = pbrs::rt::decode_varint(data, pos)? as i32;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
8 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
let w = wire.window(s, e);
let d = w.as_slice();
while ip < d.len() {
let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
pbrs::rt::skip_field(d, &mut ip, ww)?;
}
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
9 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
let w = wire.window(s, e);
let d = w.as_slice();
while ip < d.len() {
let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
pbrs::rt::skip_field(d, &mut ip, ww)?;
}
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
10 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
let w = wire.window(s, e);
let d = w.as_slice();
while ip < d.len() {
let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
pbrs::rt::skip_field(d, &mut ip, ww)?;
}
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
11 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
let w = wire.window(s, e);
let d = w.as_slice();
while ip < d.len() {
let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
pbrs::rt::skip_field(d, &mut ip, ww)?;
}
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
12 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
let w = wire.window(s, e);
let d = w.as_slice();
while ip < d.len() {
let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
pbrs::rt::skip_field(d, &mut ip, ww)?;
}
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
13 => match w {
pbrs::rt::WIRE_LEN => {
pbrs::rt::read_len_span(data, pos)?;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
14 => match w {
pbrs::rt::WIRE_LEN => {
pbrs::rt::read_len_span(data, pos)?;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
15 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
let w = wire.window(s, e);
let d = w.as_slice();
while ip < d.len() {
let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
pbrs::rt::skip_field(d, &mut ip, ww)?;
}
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
120 => match w {
pbrs::rt::WIRE_I32 => {
let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
_ => pbrs::rt::skip_field(data, pos, w)?,
}
}
if until.is_some() {
return Err(ParseError::new("truncated group"));
}
Ok(())
}
fn compute_size(&self) -> u64 {
if let Some(n) = self.cached_size.get() {
return n;
}
let mut n = self.unknown.encoded_len();
if let Some(v) = self.optional_int32 {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32) + 4;
}
if let Some(p) = self.optional_foreign_message.wire_bytes() {
n += pbrs::rt::key_len_value_len(2, p.len() as u64);
} else if let Some(m) = self.optional_foreign_message.as_deref() {
n += pbrs::rt::key_len_value_len(2, m.compute_size());
}
if let Some(v) = self.optional_foreign_enum {
n += pbrs::rt::tag_len(3, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
}
if let Some(p) = self.recursive_message.wire_bytes() {
n += pbrs::rt::key_len_value_len(4, p.len() as u64);
} else if let Some(m) = self.recursive_message.as_deref() {
n += pbrs::rt::key_len_value_len(4, m.compute_size());
}
if let Some(p) = self.repeated_int32.packed_bytes() {
n += pbrs::rt::key_len_value_len(5, p.len() as u64);
} else if !self.repeated_int32.is_empty() {
let mut payload = 0u64;
for t in self.repeated_int32.iter() {
payload += 4;
}
n += pbrs::rt::key_len_value_len(5, payload);
}
for t in self.repeated_foreign_message.iter() {
n += pbrs::rt::key_len_value_len(6, t.compute_size());
}
if let Some(p) = self.repeated_foreign_enum.packed_bytes() {
n += pbrs::rt::key_len_value_len(7, p.len() as u64);
} else if !self.repeated_foreign_enum.is_empty() {
let mut payload = 0u64;
for t in self.repeated_foreign_enum.iter() {
payload += pbrs::rt::varint_len((*t) as u64);
}
n += pbrs::rt::key_len_value_len(7, payload);
}
if !self.map_int32_int32.is_empty() {
for (k, v) in self.map_int32_int32.pairs() {
let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
+ 4
+ pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
+ 4;
n += pbrs::rt::key_len_value_len(8, inner);
}
}
if !self.map_bool_bool.is_empty() {
for (k, v) in self.map_bool_bool.pairs() {
let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len(u64::from(*k))
+ pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len(u64::from(*v));
n += pbrs::rt::key_len_value_len(9, inner);
}
}
if !self.map_string_string.is_empty() {
for (k, v) in self.map_string_string.pairs() {
let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
+ pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
n += pbrs::rt::key_len_value_len(10, inner);
}
}
if !self.map_string_foreign_message.is_empty() {
for (k, v) in self.map_string_foreign_message.pairs() {
let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
+ pbrs::rt::key_len_value_len(2, v.compute_size());
n += pbrs::rt::key_len_value_len(11, inner);
}
}
if !self.map_string_foreign_enum.is_empty() {
for (k, v) in self.map_string_foreign_enum.pairs() {
let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
+ pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len((*v) as u64);
n += pbrs::rt::key_len_value_len(12, inner);
}
}
if let Some(s) = &self.optional_bytes {
n += pbrs::rt::key_len_value_len(13, s.as_bytes().len() as u64);
}
for t in self.repeated_bytes.iter() {
n += pbrs::rt::key_len_value_len(14, t.as_bytes().len() as u64);
}
if !self.map_string_bytes.is_empty() {
for (k, v) in self.map_string_bytes.pairs() {
let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
+ pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
n += pbrs::rt::key_len_value_len(15, inner);
}
}
if let Some(v) = self.extension_int32 {
n += pbrs::rt::tag_len(120, pbrs::rt::WIRE_I32) + 4;
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if let Some(v) = self.optional_int32 {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
(out).extend_from_slice(&((v) as u32).to_le_bytes());
}
if let Some(p) = self.optional_foreign_message.wire_bytes() {
pbrs::rt::encode_len_header(out, 2, p.len() as u64);
out.extend_from_slice(p);
} else if let Some(m) = self.optional_foreign_message.as_deref() {
pbrs::rt::encode_len_header(out, 2, m.compute_size());
m.write_to(out);
}
if let Some(v) = self.optional_foreign_enum {
pbrs::rt::encode_tag(out, 3, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, v as u64);
}
if let Some(p) = self.recursive_message.wire_bytes() {
pbrs::rt::encode_len_header(out, 4, p.len() as u64);
out.extend_from_slice(p);
} else if let Some(m) = self.recursive_message.as_deref() {
pbrs::rt::encode_len_header(out, 4, m.compute_size());
m.write_to(out);
}
if let Some(p) = self.repeated_int32.packed_bytes() {
pbrs::rt::encode_len_header(out, 5, p.len() as u64);
out.extend_from_slice(p);
} else if !self.repeated_int32.is_empty() {
let mut payload = 0u64;
for t in self.repeated_int32.iter() {
payload += 4;
}
pbrs::rt::encode_len_header(out, 5, payload);
for t in self.repeated_int32.iter() {
(out).extend_from_slice(&((*t) as u32).to_le_bytes());
}
}
for t in self.repeated_foreign_message.iter() {
pbrs::rt::encode_len_header(out, 6, t.compute_size());
t.write_to(out);
}
if let Some(p) = self.repeated_foreign_enum.packed_bytes() {
pbrs::rt::encode_len_header(out, 7, p.len() as u64);
out.extend_from_slice(p);
} else if !self.repeated_foreign_enum.is_empty() {
let mut payload = 0u64;
for t in self.repeated_foreign_enum.iter() {
payload += pbrs::rt::varint_len((*t) as u64);
}
pbrs::rt::encode_len_header(out, 7, payload);
for t in self.repeated_foreign_enum.iter() {
pbrs::rt::encode_varint(out, *t as u64);
}
}
if !self.map_int32_int32.is_empty() {
for (k, v) in self.map_int32_int32.pairs() {
let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
+ 4
+ pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
+ 4;
pbrs::rt::encode_tag(out, 8, pbrs::rt::WIRE_LEN);
pbrs::rt::encode_varint(out, inner);
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
out.extend_from_slice(&(*k as u32).to_le_bytes());
pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I32);
out.extend_from_slice(&(*v as u32).to_le_bytes());
}
}
if !self.map_bool_bool.is_empty() {
for (k, v) in self.map_bool_bool.pairs() {
let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len(u64::from(*k))
+ pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len(u64::from(*v));
pbrs::rt::encode_tag(out, 9, pbrs::rt::WIRE_LEN);
pbrs::rt::encode_varint(out, inner);
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, u64::from(*k));
pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, u64::from(*v));
}
}
if !self.map_string_string.is_empty() {
for (k, v) in self.map_string_string.pairs() {
let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
+ pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
pbrs::rt::encode_tag(out, 10, pbrs::rt::WIRE_LEN);
pbrs::rt::encode_varint(out, inner);
pbrs::rt::encode_len_field(out, 1, k.as_bytes());
pbrs::rt::encode_len_field(out, 2, v.as_bytes());
}
}
if !self.map_string_foreign_message.is_empty() {
for (k, v) in self.map_string_foreign_message.pairs() {
let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
+ pbrs::rt::key_len_value_len(2, v.compute_size());
pbrs::rt::encode_tag(out, 11, pbrs::rt::WIRE_LEN);
pbrs::rt::encode_varint(out, inner);
pbrs::rt::encode_len_field(out, 1, k.as_bytes());
pbrs::rt::encode_len_header(out, 2, v.compute_size());
v.write_to(out);
}
}
if !self.map_string_foreign_enum.is_empty() {
for (k, v) in self.map_string_foreign_enum.pairs() {
let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
+ pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len((*v) as u64);
pbrs::rt::encode_tag(out, 12, pbrs::rt::WIRE_LEN);
pbrs::rt::encode_varint(out, inner);
pbrs::rt::encode_len_field(out, 1, k.as_bytes());
pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, *v as u64);
}
}
if let Some(s) = &self.optional_bytes {
pbrs::rt::encode_len_field(out, 13, s.as_bytes());
}
for t in self.repeated_bytes.iter() {
pbrs::rt::encode_len_field(out, 14, t.as_bytes());
}
if !self.map_string_bytes.is_empty() {
for (k, v) in self.map_string_bytes.pairs() {
let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
+ pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
pbrs::rt::encode_tag(out, 15, pbrs::rt::WIRE_LEN);
pbrs::rt::encode_varint(out, inner);
pbrs::rt::encode_len_field(out, 1, k.as_bytes());
pbrs::rt::encode_len_field(out, 2, v.as_bytes());
}
}
if let Some(v) = self.extension_int32 {
pbrs::rt::encode_tag(out, 120, pbrs::rt::WIRE_I32);
(out).extend_from_slice(&((v) as u32).to_le_bytes());
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("json"))?;
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.TestAllTypesEditionUnstable")
.ok_or_else(|| SerializeError::new("missing desc"))?;
pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
.map_err(|_| SerializeError::new("json"))?
.to_json()
}
pub fn from_json(json: &str) -> Result<Self, ParseError> {
Self::from_json_ignore(json, false)
}
pub fn from_json_ignore(json: &str, ignore: bool) -> Result<Self, ParseError> {
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.TestAllTypesEditionUnstable")
.ok_or_else(|| ParseError::owned("missing desc".into()))?;
let d = pbrs::DynamicMessage::from_json_with_pool(desc, Some(pool), json, ignore)?;
let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
<Self as pbrs::Parse>::parse(&b)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.TestAllTypesEditionUnstable")
.ok_or_else(|| SerializeError::new("missing desc"))?;
pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
.map_err(|_| SerializeError::new("text"))?
.to_text()
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.TestAllTypesEditionUnstable")
.ok_or_else(|| SerializeError::new("missing desc"))?;
pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
.map_err(|_| SerializeError::new("text"))?
.to_text_with_unknown()
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
let pool = generated_pool();
let desc = pool
.get_message("protobuf_test_messages.edition_unstable.TestAllTypesEditionUnstable")
.ok_or_else(|| ParseError::owned("missing desc".into()))?;
let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
<Self as pbrs::Parse>::parse(&b)
}
}
pbrs::impl_typed_message!(
TestAllTypesEditionUnstable,
TestAllTypesEditionUnstableView,
TestAllTypesEditionUnstableMut
);
fn decode_map_entry_TestAllTypesEditionUnstable_map_int32_int32_8(
wire: &pbrs::rt::Wire,
depth: u32,
) -> Result<(i32, i32), ParseError> {
let _ = depth;
let data = wire.as_slice();
let mut key = i32::default();
let mut val = i32::default();
let mut pos = 0;
while pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
match (n, w) {
(1, pbrs::rt::WIRE_I32) => key = pbrs::rt::read_fixed32(data, &mut pos)? as i32,
(2, pbrs::rt::WIRE_I32) => val = pbrs::rt::read_fixed32(data, &mut pos)? as i32,
_ => pbrs::rt::skip_field(data, &mut pos, w)?,
}
}
Ok((key, val))
}
fn decode_map_entry_TestAllTypesEditionUnstable_map_bool_bool_9(
wire: &pbrs::rt::Wire,
depth: u32,
) -> Result<(bool, bool), ParseError> {
let _ = depth;
let data = wire.as_slice();
let mut key = bool::default();
let mut val = bool::default();
let mut pos = 0;
while pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
match (n, w) {
(1, pbrs::rt::WIRE_VARINT) => key = pbrs::rt::decode_varint(data, &mut pos)? != 0,
(2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? != 0,
_ => pbrs::rt::skip_field(data, &mut pos, w)?,
}
}
Ok((key, val))
}
fn decode_map_entry_TestAllTypesEditionUnstable_map_string_string_10(
wire: &pbrs::rt::Wire,
depth: u32,
) -> Result<(pbrs::rt::LazyStr, pbrs::rt::LazyStr), ParseError> {
let _ = depth;
let data = wire.as_slice();
let mut key = pbrs::rt::LazyStr::default();
let mut val = pbrs::rt::LazyStr::default();
let mut pos = 0;
while pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
match (n, w) {
(1, pbrs::rt::WIRE_LEN) => {
let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
std::str::from_utf8(&data[s..e])
.map_err(|_| ParseError::new("invalid utf-8"))?;
key = pbrs::rt::LazyStr::from_span(wire, s, e);
}
(2, pbrs::rt::WIRE_LEN) => {
let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
std::str::from_utf8(&data[s..e])
.map_err(|_| ParseError::new("invalid utf-8"))?;
val = pbrs::rt::LazyStr::from_span(wire, s, e);
}
_ => pbrs::rt::skip_field(data, &mut pos, w)?,
}
}
Ok((key, val))
}
fn decode_map_entry_TestAllTypesEditionUnstable_map_string_foreign_message_11(
wire: &pbrs::rt::Wire,
depth: u32,
) -> Result<(pbrs::rt::LazyStr, ForeignMessageEditionUnstable), ParseError> {
let _ = depth;
let data = wire.as_slice();
let mut key = pbrs::rt::LazyStr::default();
let mut val = ForeignMessageEditionUnstable::default();
let mut pos = 0;
while pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
match (n, w) {
(1, pbrs::rt::WIRE_LEN) => {
let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
std::str::from_utf8(&data[s..e])
.map_err(|_| ParseError::new("invalid utf-8"))?;
key = pbrs::rt::LazyStr::from_span(wire, s, e);
}
(2, pbrs::rt::WIRE_LEN) => {
let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
let mut ip = 0;
let mut sw = None;
val.merge_inner(&data[s..e], &mut sw, &mut ip, depth, true, None)?;
}
_ => pbrs::rt::skip_field(data, &mut pos, w)?,
}
}
Ok((key, val))
}
fn decode_map_entry_TestAllTypesEditionUnstable_map_string_foreign_enum_12(
wire: &pbrs::rt::Wire,
depth: u32,
) -> Result<(pbrs::rt::LazyStr, i32), ParseError> {
let _ = depth;
let data = wire.as_slice();
let mut key = pbrs::rt::LazyStr::default();
let mut val = i32::default();
let mut pos = 0;
while pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
match (n, w) {
(1, pbrs::rt::WIRE_LEN) => {
let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
std::str::from_utf8(&data[s..e])
.map_err(|_| ParseError::new("invalid utf-8"))?;
key = pbrs::rt::LazyStr::from_span(wire, s, e);
}
(2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? as i32,
_ => pbrs::rt::skip_field(data, &mut pos, w)?,
}
}
Ok((key, val))
}
fn decode_map_entry_TestAllTypesEditionUnstable_map_string_bytes_15(
wire: &pbrs::rt::Wire,
depth: u32,
) -> Result<(pbrs::rt::LazyStr, pbrs::rt::LazyBytes), ParseError> {
let _ = depth;
let data = wire.as_slice();
let mut key = pbrs::rt::LazyStr::default();
let mut val = pbrs::rt::LazyBytes::default();
let mut pos = 0;
while pos < data.len() {
let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
match (n, w) {
(1, pbrs::rt::WIRE_LEN) => {
let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
std::str::from_utf8(&data[s..e])
.map_err(|_| ParseError::new("invalid utf-8"))?;
key = pbrs::rt::LazyStr::from_span(wire, s, e);
}
(2, pbrs::rt::WIRE_LEN) => {
let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
val = pbrs::rt::LazyBytes::from_wire_span(wire, s, e);
}
_ => pbrs::rt::skip_field(data, &mut pos, w)?,
}
}
Ok((key, val))
}
}
#[allow(unused_imports, reason = "generated by protoc-gen-pbrs")]
pub use __gen::*;