#[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 NullValue(i32);
#[allow(non_upper_case_globals, reason = "protobuf enum names")]
impl NullValue {
pub const NullValue: NullValue = NullValue(0);
fn constant_name(self) -> Option<&'static str> {
#[allow(unreachable_patterns, reason = "open enums")]
Some(match self.0 {
0 => "NullValue",
_ => return None,
})
}
}
impl From<NullValue> for i32 {
fn from(v: NullValue) -> i32 {
v.0
}
}
impl From<i32> for NullValue {
fn from(val: i32) -> Self {
Self(val)
}
}
impl Default for NullValue {
fn default() -> Self {
Self(0)
}
}
impl std::fmt::Debug for NullValue {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(n) = self.constant_name() {
write!(f, "NullValue::{n}")
} else {
write!(f, "NullValue::from({})", self.0)
}
}
}
impl pbrs::__internal::SealedInternal for NullValue {}
impl pbrs::Proxied for NullValue {
type View<'msg> = NullValue;
}
impl pbrs::AsView for NullValue {
type Proxied = Self;
fn as_view(&self) -> Self {
*self
}
}
impl<'msg> pbrs::IntoView<'msg> for NullValue {
fn into_view<'shorter>(self) -> Self
where
'msg: 'shorter,
{
self
}
}
impl Enum for NullValue {
const NAME: &'static str = "NullValue";
fn is_known(value: i32) -> bool {
matches!(value, 0)
}
}
#[derive(Clone, Debug)]
pub struct ListValue {
values: Repeated<PbValue>,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for ListValue {
fn eq(&self, other: &Self) -> bool {
if self.values != other.values {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for ListValue {}
impl Default for ListValue {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl ListValue {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.ListValue";
pub fn values(&self) -> RepeatedView<'_, PbValue> {
self.values.as_view()
}
pub fn values_mut(&mut self) -> RepeatedMut<'_, PbValue> {
self.cached_size.dirty();
self.values.as_mut()
}
pub fn set_values(&mut self, v: impl IntoIterator<Item = PbValue>) {
self.cached_size.dirty();
self.values = v.into_iter().collect();
}
#[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 rest = data.len().saturating_sub(e);
if rest > 2 {
self.values.reserve(1 + rest / (e - s + 4).max(1));
}
let mut inner = PbValue::default();
let mut ip = 0;
let mut sw = None;
inner.merge_inner(
&data[s..e],
&mut sw,
&mut ip,
depth + 1,
true,
None,
)?;
self.values.push(inner);
while *pos < data.len() {
let save = *pos;
match pbrs::rt::decode_tag(data, pos) {
Ok((n2, w2)) if n2 == 1 && w2 == pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut inner = PbValue::default();
let mut ip = 0;
let mut sw = None;
inner.merge_inner(
&data[s..e],
&mut sw,
&mut ip,
depth + 1,
true,
None,
)?;
self.values.push(inner);
}
Ok(_) => {
*pos = save;
break;
}
Err(e) => return Err(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)?;
let mut ip = 0;
PbValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
}
_ => 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();
for t in self.values.iter() {
n += pbrs::rt::key_len_value_len(1, t.compute_size());
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
for t in self.values.iter() {
pbrs::rt::encode_len_header(out, 1, t.compute_size());
t.write_to(out);
}
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.ListValue")
.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.ListValue")
.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.ListValue")
.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.ListValue")
.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.ListValue")
.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!(ListValue, ListValueView, ListValueMut);
#[derive(Clone, Debug)]
pub struct Struct {
fields: Map<pbrs::rt::LazyStr, PbValue>,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for Struct {
fn eq(&self, other: &Self) -> bool {
if self.fields != other.fields {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for Struct {}
impl Default for Struct {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl Struct {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.Struct";
pub fn fields(&self) -> MapView<'_, pbrs::rt::LazyStr, PbValue> {
self.fields.as_view()
}
pub fn fields_mut(&mut self) -> MapMut<'_, pbrs::rt::LazyStr, PbValue> {
self.cached_size.dirty();
self.fields.as_mut()
}
pub fn set_fields(&mut self, v: Map<pbrs::rt::LazyStr, PbValue>) {
self.cached_size.dirty();
self.fields = v;
}
#[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 (kk, vv) = decode_map_entry_Struct_fields_1(
&pbrs::rt::Wire::ensure(wire, data).window(s, e),
depth + 1,
)?;
self.fields.push_entry(kk, vv);
}
_ => 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)?;
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)?,
},
_ => 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.fields.is_empty() {
for (k, v) in self.fields.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(1, inner);
}
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if !self.fields.is_empty() {
for (k, v) in self.fields.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, 1, 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);
}
}
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.Struct")
.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.Struct")
.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.Struct")
.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.Struct")
.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.Struct")
.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!(Struct, StructView, StructMut);
fn decode_map_entry_Struct_fields_1(
wire: &pbrs::rt::Wire,
depth: u32,
) -> Result<(pbrs::rt::LazyStr, PbValue), ParseError> {
let _ = depth;
let data = wire.as_slice();
let mut key = pbrs::rt::LazyStr::default();
let mut val = PbValue::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))
}
#[derive(Clone, Debug)]
pub struct PbValue {
null_value: Option<i32>,
number_value: Option<f64>,
string_value: Option<Box<pbrs::rt::LazyStr>>,
bool_value: pbrs::rt::OptBool,
struct_value: pbrs::rt::LazyMsg<Struct>,
list_value: pbrs::rt::LazyMsg<ListValue>,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for PbValue {
fn eq(&self, other: &Self) -> bool {
if self.null_value != other.null_value {
return false;
}
if self.number_value != other.number_value {
return false;
}
if self.string_value != other.string_value {
return false;
}
if self.bool_value != other.bool_value {
return false;
}
if self.struct_value != other.struct_value {
return false;
}
if self.list_value != other.list_value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for PbValue {}
impl Default for PbValue {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl PbValue {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.Value";
pub fn has_null_value(&self) -> bool {
self.null_value.is_some()
}
pub fn null_value(&self) -> NullValue {
NullValue(self.null_value.unwrap_or(0))
}
pub fn null_value_opt(&self) -> Option<NullValue> {
self.null_value.map(|v| NullValue(v))
}
pub fn set_null_value(&mut self, v: impl Into<i32>) {
self.cached_size.dirty();
self.number_value = None;
self.string_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.struct_value = Default::default();
self.list_value = Default::default();
self.null_value = Some(v.into());
}
pub fn clear_null_value(&mut self) {
self.cached_size.dirty();
self.null_value = None;
}
pub fn has_number_value(&self) -> bool {
self.number_value.is_some()
}
pub fn number_value(&self) -> f64 {
self.number_value.unwrap_or(0.0)
}
pub fn number_value_opt(&self) -> Option<f64> {
self.number_value.map(|v| v)
}
pub fn set_number_value(&mut self, v: f64) {
self.cached_size.dirty();
self.null_value = None;
self.string_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.struct_value = Default::default();
self.list_value = Default::default();
self.number_value = Some(v);
}
pub fn clear_number_value(&mut self) {
self.cached_size.dirty();
self.number_value = None;
}
pub fn has_string_value(&self) -> bool {
self.string_value.is_some()
}
pub fn string_value(&self) -> &pbrs::ProtoStr {
self.string_value
.as_ref()
.map(|s| s.as_view())
.unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
}
pub fn string_value_opt(&self) -> Option<&pbrs::ProtoStr> {
self.string_value.as_ref().map(|s| s.as_view())
}
pub fn set_string_value(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
self.cached_size.dirty();
self.null_value = None;
self.number_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.struct_value = Default::default();
self.list_value = Default::default();
self.string_value = Some(Box::new(pbrs::rt::LazyStr::owned(
v.into_proxied(pbrs::__internal::Private),
)));
}
pub fn clear_string_value(&mut self) {
self.cached_size.dirty();
self.string_value = None;
}
pub fn has_bool_value(&self) -> bool {
self.bool_value.is_some()
}
pub fn bool_value(&self) -> bool {
self.bool_value.unwrap_or(false)
}
pub fn bool_value_opt(&self) -> Option<bool> {
self.bool_value.get()
}
pub fn set_bool_value(&mut self, v: bool) {
self.cached_size.dirty();
self.null_value = None;
self.number_value = None;
self.string_value = None;
self.struct_value = Default::default();
self.list_value = Default::default();
self.bool_value = pbrs::rt::OptBool::some(v);
}
pub fn clear_bool_value(&mut self) {
self.cached_size.dirty();
self.bool_value = pbrs::rt::OptBool::NONE;
}
pub fn has_struct_value(&self) -> bool {
self.struct_value.is_some()
}
pub fn struct_value(&self) -> &Struct {
self.struct_value
.as_deref()
.unwrap_or(pbrs::gen_support::default_instance_of())
}
pub fn struct_value_opt(&self) -> Option<&Struct> {
self.struct_value.as_deref()
}
pub fn struct_value_view(&self) -> StructView<'_> {
StructView(self.struct_value())
}
pub fn set_struct_value(&mut self, v: Struct) {
self.cached_size.dirty();
self.null_value = None;
self.number_value = None;
self.string_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.list_value = Default::default();
self.struct_value = pbrs::rt::LazyMsg::from_owned(v);
}
pub fn struct_value_mut(&mut self) -> &mut Struct {
self.cached_size.dirty();
self.struct_value.get_or_insert()
}
pub fn clear_struct_value(&mut self) {
self.cached_size.dirty();
self.struct_value.clear();
}
pub fn has_list_value(&self) -> bool {
self.list_value.is_some()
}
pub fn list_value(&self) -> &ListValue {
self.list_value
.as_deref()
.unwrap_or(pbrs::gen_support::default_instance_of())
}
pub fn list_value_opt(&self) -> Option<&ListValue> {
self.list_value.as_deref()
}
pub fn list_value_view(&self) -> ListValueView<'_> {
ListValueView(self.list_value())
}
pub fn set_list_value(&mut self, v: ListValue) {
self.cached_size.dirty();
self.null_value = None;
self.number_value = None;
self.string_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.struct_value = Default::default();
self.list_value = pbrs::rt::LazyMsg::from_owned(v);
}
pub fn list_value_mut(&mut self) -> &mut ListValue {
self.cached_size.dirty();
self.list_value.get_or_insert()
}
pub fn clear_list_value(&mut self) {
self.cached_size.dirty();
self.list_value.clear();
}
#[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_VARINT => {
self.number_value = None;
self.string_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.struct_value = Default::default();
self.list_value = Default::default();
self.null_value = Some(pbrs::rt::decode_varint(data, pos)? as i32);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
2 => match w {
pbrs::rt::WIRE_I64 => {
self.null_value = None;
self.string_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.struct_value = Default::default();
self.list_value = Default::default();
self.number_value =
Some(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
3 => match w {
pbrs::rt::WIRE_LEN => {
self.null_value = None;
self.number_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.struct_value = Default::default();
self.list_value = Default::default();
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.string_value = Some(Box::new(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)?),
},
4 => match w {
pbrs::rt::WIRE_VARINT => {
self.null_value = None;
self.number_value = None;
self.string_value = None;
self.struct_value = Default::default();
self.list_value = Default::default();
self.bool_value =
pbrs::rt::OptBool::some(pbrs::rt::decode_varint(data, pos)? != 0);
}
_ => self
.unknown
.fields
.push(pbrs::rt::capture_unknown(data, pos, n, w)?),
},
5 => match w {
pbrs::rt::WIRE_LEN => {
self.null_value = None;
self.number_value = None;
self.string_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.list_value = Default::default();
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
if self.struct_value.is_some() {
let mut ip = 0;
let mut sw = None;
self.struct_value.get_or_insert().merge_inner(
&data[s..e],
&mut sw,
&mut ip,
depth + 1,
true,
None,
)?;
} else {
let mut ip = 0;
Struct::validate_inner(
&pbrs::rt::Wire::ensure(wire, data).window(s, e),
&mut ip,
depth + 1,
)?;
self.struct_value = 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)?),
},
6 => match w {
pbrs::rt::WIRE_LEN => {
self.null_value = None;
self.number_value = None;
self.string_value = None;
self.bool_value = pbrs::rt::OptBool::NONE;
self.struct_value = Default::default();
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
if self.list_value.is_some() {
let mut ip = 0;
let mut sw = None;
self.list_value.get_or_insert().merge_inner(
&data[s..e],
&mut sw,
&mut ip,
depth + 1,
true,
None,
)?;
} else {
let mut ip = 0;
ListValue::validate_inner(
&pbrs::rt::Wire::ensure(wire, data).window(s, e),
&mut ip,
depth + 1,
)?;
self.list_value = 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)?),
},
_ => 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_VARINT => {
let _ = pbrs::rt::decode_varint(data, pos)? as i32;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
2 => match w {
pbrs::rt::WIRE_I64 => {
let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
3 => 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)?,
},
4 => match w {
pbrs::rt::WIRE_VARINT => {
let _ = pbrs::rt::decode_varint(data, pos)? != 0;
}
_ => pbrs::rt::skip_field(data, pos, w)?,
},
5 => match w {
pbrs::rt::WIRE_LEN => {
let (s, e) = pbrs::rt::read_len_span(data, pos)?;
let mut ip = 0;
Struct::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
}
_ => 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;
ListValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
}
_ => 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.null_value {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
}
if let Some(v) = self.number_value {
n += pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64) + 8;
}
if let Some(s) = &self.string_value {
n += pbrs::rt::key_len_value_len(3, s.as_bytes().len() as u64);
}
if let Some(v) = self.bool_value.get() {
n += pbrs::rt::tag_len(4, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len(u64::from(v));
}
if let Some(p) = self.struct_value.wire_bytes() {
n += pbrs::rt::key_len_value_len(5, p.len() as u64);
} else if let Some(m) = self.struct_value.as_deref() {
n += pbrs::rt::key_len_value_len(5, m.compute_size());
}
if let Some(p) = self.list_value.wire_bytes() {
n += pbrs::rt::key_len_value_len(6, p.len() as u64);
} else if let Some(m) = self.list_value.as_deref() {
n += pbrs::rt::key_len_value_len(6, m.compute_size());
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if let Some(v) = self.null_value {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, v as u64);
}
if let Some(v) = self.number_value {
pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I64);
(out).extend_from_slice(&(v).to_bits().to_le_bytes());
}
if let Some(s) = &self.string_value {
pbrs::rt::encode_len_field(out, 3, s.as_bytes());
}
if let Some(v) = self.bool_value.get() {
pbrs::rt::encode_tag(out, 4, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, u64::from(v));
}
if let Some(p) = self.struct_value.wire_bytes() {
pbrs::rt::encode_len_header(out, 5, p.len() as u64);
out.extend_from_slice(p);
} else if let Some(m) = self.struct_value.as_deref() {
pbrs::rt::encode_len_header(out, 5, m.compute_size());
m.write_to(out);
}
if let Some(p) = self.list_value.wire_bytes() {
pbrs::rt::encode_len_header(out, 6, p.len() as u64);
out.extend_from_slice(p);
} else if let Some(m) = self.list_value.as_deref() {
pbrs::rt::encode_len_header(out, 6, m.compute_size());
m.write_to(out);
}
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.Value")
.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.Value")
.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.Value")
.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.Value")
.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.Value")
.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!(PbValue, PbValueView, PbValueMut);
}
#[allow(unused_imports, reason = "generated by protoc-gen-pbrs")]
pub use __gen::*;