#[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()
}
#[derive(Clone, Debug)]
pub struct Any {
type_url: pbrs::rt::LazyStr,
value: pbrs::rt::LazyBytes,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for Any {
fn eq(&self, other: &Self) -> bool {
if self.type_url != other.type_url {
return false;
}
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for Any {}
impl Default for Any {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl Any {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.Any";
pub fn type_url(&self) -> &pbrs::ProtoStr {
self.type_url.as_view()
}
pub fn set_type_url(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
self.cached_size.dirty();
self.type_url = pbrs::rt::LazyStr::owned(v.into_proxied(pbrs::__internal::Private));
}
pub fn value(&self) -> &[u8] {
self.value.as_bytes()
}
pub fn set_value(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
self.cached_size.dirty();
self.value = pbrs::rt::LazyBytes::owned(v.into_proxied(pbrs::__internal::Private));
}
#[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_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let b = &data[s..e];
std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
self.type_url = pbrs::rt::LazyStr::from_span(
pbrs::rt::Wire::ensure(wire, data),
s,
e,
);
}
_ => 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)?;
self.value = pbrs::rt::LazyBytes::from_wire(
pbrs::rt::Wire::ensure(wire, data).window(s, e),
);
}
_ => 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_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
std::str::from_utf8(&data[s..e])
.map_err(|_| ParseError::new("invalid utf-8"))?;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
2 => match w {
pbrs::rt::WIRE_LEN => {
pbrs::rt::read_len_span(data, pos)?;
}
_ => 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 !self.type_url.is_empty() {
n += pbrs::rt::key_len_value_len(1, self.type_url.as_bytes().len() as u64);
}
if !self.value.is_empty() {
n += pbrs::rt::key_len_value_len(2, self.value.as_bytes().len() as u64);
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if !self.type_url.is_empty() {
pbrs::rt::encode_len_field(out, 1, self.type_url.as_bytes());
}
if !self.value.is_empty() {
pbrs::rt::encode_len_field(out, 2, self.value.as_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("google.protobuf.Any")
.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("google.protobuf.Any")
.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("google.protobuf.Any")
.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("google.protobuf.Any")
.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("google.protobuf.Any")
.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!(Any, AnyView, AnyMut);
}
#[allow(unused_imports, reason = "generated by protoc-gen-pbrs")]
pub use __gen::*;