#[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 BoolValue {
value: bool,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for BoolValue {
fn eq(&self, other: &Self) -> bool {
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for BoolValue {}
impl Default for BoolValue {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl BoolValue {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.BoolValue";
pub fn value(&self) -> bool {
self.value
}
pub fn set_value(&mut self, v: bool) {
self.cached_size.dirty();
self.value = 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_VARINT => {
self.value = pbrs::rt::decode_varint(data, pos)? != 0;
}
_ => 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)? != 0;
}
_ => 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.value {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len(u64::from(self.value));
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if self.value {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, u64::from(self.value));
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
Ok(self.to_json_value()?.to_string())
}
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 v = pbrs::json::parse(json)?;
Self::from_json_value(&v, ignore)
}
fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
Ok(pbrs::json::boolean(self.value()))
}
fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
let mut msg = Self::new();
msg.set_value(pbrs::json::as_bool(v)?);
Ok(msg)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
Ok(out)
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
Ok(out)
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
Self::from_text_value(&pbrs::text::parse(text)?)
}
fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
if self.value() {
pbrs::text::write_named_bool(out, indent, "value", self.value());
}
Ok(())
}
fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
let mut msg = Self::new();
for (key, val) in fields {
match key.as_str() {
"value" => {
msg.set_value(val.as_bool()?);
}
_ => return Err(ParseError::owned(format!("unknown field {key}"))),
}
}
Ok(msg)
}
}
pbrs::impl_typed_message!(BoolValue, BoolValueView, BoolValueMut);
#[derive(Clone, Debug)]
pub struct BytesValue {
value: pbrs::rt::LazyBytes,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for BytesValue {
fn eq(&self, other: &Self) -> bool {
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for BytesValue {}
impl Default for BytesValue {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl BytesValue {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.BytesValue";
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)?;
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 => {
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.value.is_empty() {
n += pbrs::rt::key_len_value_len(1, 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.value.is_empty() {
pbrs::rt::encode_len_field(out, 1, self.value.as_bytes());
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
Ok(self.to_json_value()?.to_string())
}
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 v = pbrs::json::parse(json)?;
Self::from_json_value(&v, ignore)
}
fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
Ok(pbrs::json::bytes(self.value()))
}
fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
let mut msg = Self::new();
msg.set_value(pbrs::json::as_bytes(v)?);
Ok(msg)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
Ok(out)
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
Ok(out)
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
Self::from_text_value(&pbrs::text::parse(text)?)
}
fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
if !self.value().is_empty() {
pbrs::text::write_named_string(out, indent, "value", self.value());
}
Ok(())
}
fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
let mut msg = Self::new();
for (key, val) in fields {
match key.as_str() {
"value" => {
msg.set_value(val.as_bytes()?);
}
_ => return Err(ParseError::owned(format!("unknown field {key}"))),
}
}
Ok(msg)
}
}
pbrs::impl_typed_message!(BytesValue, BytesValueView, BytesValueMut);
#[derive(Clone, Debug)]
pub struct DoubleValue {
value: f64,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for DoubleValue {
fn eq(&self, other: &Self) -> bool {
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for DoubleValue {}
impl Default for DoubleValue {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl DoubleValue {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.DoubleValue";
pub fn value(&self) -> f64 {
self.value
}
pub fn set_value(&mut self, v: f64) {
self.cached_size.dirty();
self.value = 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_I64 => {
self.value = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
}
_ => 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_I64 => {
let _ = f64::from_bits(pbrs::rt::read_fixed64(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.value.to_bits() != 0 {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64) + 8;
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if self.value.to_bits() != 0 {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I64);
(out).extend_from_slice(&(self.value).to_bits().to_le_bytes());
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
Ok(self.to_json_value()?.to_string())
}
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 v = pbrs::json::parse(json)?;
Self::from_json_value(&v, ignore)
}
fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
Ok(pbrs::json::double(self.value()))
}
fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
let mut msg = Self::new();
msg.set_value(pbrs::json::as_f64(v)?);
Ok(msg)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
Ok(out)
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
Ok(out)
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
Self::from_text_value(&pbrs::text::parse(text)?)
}
fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
if self.value().to_bits() != 0 {
pbrs::text::write_named_double(out, indent, "value", self.value());
}
Ok(())
}
fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
let mut msg = Self::new();
for (key, val) in fields {
match key.as_str() {
"value" => {
msg.set_value(val.as_f64()?);
}
_ => return Err(ParseError::owned(format!("unknown field {key}"))),
}
}
Ok(msg)
}
}
pbrs::impl_typed_message!(DoubleValue, DoubleValueView, DoubleValueMut);
#[derive(Clone, Debug)]
pub struct FloatValue {
value: f32,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for FloatValue {
fn eq(&self, other: &Self) -> bool {
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for FloatValue {}
impl Default for FloatValue {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl FloatValue {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.FloatValue";
pub fn value(&self) -> f32 {
self.value
}
pub fn set_value(&mut self, v: f32) {
self.cached_size.dirty();
self.value = 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_I32 => {
self.value = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
}
_ => 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 _ = f32::from_bits(pbrs::rt::read_fixed32(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.value.to_bits() != 0 {
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 self.value.to_bits() != 0 {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
(out).extend_from_slice(&(self.value).to_bits().to_le_bytes());
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
Ok(self.to_json_value()?.to_string())
}
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 v = pbrs::json::parse(json)?;
Self::from_json_value(&v, ignore)
}
fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
Ok(pbrs::json::float(self.value()))
}
fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
let mut msg = Self::new();
msg.set_value(pbrs::json::as_f32(v)?);
Ok(msg)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
Ok(out)
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
Ok(out)
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
Self::from_text_value(&pbrs::text::parse(text)?)
}
fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
if self.value().to_bits() != 0 {
pbrs::text::write_named_float(out, indent, "value", self.value());
}
Ok(())
}
fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
let mut msg = Self::new();
for (key, val) in fields {
match key.as_str() {
"value" => {
msg.set_value(val.as_f32()?);
}
_ => return Err(ParseError::owned(format!("unknown field {key}"))),
}
}
Ok(msg)
}
}
pbrs::impl_typed_message!(FloatValue, FloatValueView, FloatValueMut);
#[derive(Clone, Debug)]
pub struct Int32Value {
value: i32,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for Int32Value {
fn eq(&self, other: &Self) -> bool {
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for Int32Value {}
impl Default for Int32Value {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl Int32Value {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.Int32Value";
pub fn value(&self) -> i32 {
self.value
}
pub fn set_value(&mut self, v: i32) {
self.cached_size.dirty();
self.value = 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_VARINT => {
self.value = pbrs::rt::decode_varint(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_VARINT => {
let _ = pbrs::rt::decode_varint(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 self.value != 0 {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len((self.value) as u64);
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if self.value != 0 {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, self.value as u64);
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
Ok(self.to_json_value()?.to_string())
}
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 v = pbrs::json::parse(json)?;
Self::from_json_value(&v, ignore)
}
fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
Ok(pbrs::json::int32(self.value()))
}
fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
let mut msg = Self::new();
msg.set_value(pbrs::json::as_i32(v)?);
Ok(msg)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
Ok(out)
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
Ok(out)
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
Self::from_text_value(&pbrs::text::parse(text)?)
}
fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
if self.value() != 0 {
pbrs::text::write_named_int32(out, indent, "value", self.value());
}
Ok(())
}
fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
let mut msg = Self::new();
for (key, val) in fields {
match key.as_str() {
"value" => {
msg.set_value(val.as_i32()?);
}
_ => return Err(ParseError::owned(format!("unknown field {key}"))),
}
}
Ok(msg)
}
}
pbrs::impl_typed_message!(Int32Value, Int32ValueView, Int32ValueMut);
#[derive(Clone, Debug)]
pub struct Int64Value {
value: i64,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for Int64Value {
fn eq(&self, other: &Self) -> bool {
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for Int64Value {}
impl Default for Int64Value {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl Int64Value {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.Int64Value";
pub fn value(&self) -> i64 {
self.value
}
pub fn set_value(&mut self, v: i64) {
self.cached_size.dirty();
self.value = 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_VARINT => {
self.value = pbrs::rt::decode_varint(data, pos)? as i64;
}
_ => 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 i64;
}
_ => 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.value != 0 {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len((self.value) as u64);
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if self.value != 0 {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, self.value as u64);
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
Ok(self.to_json_value()?.to_string())
}
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 v = pbrs::json::parse(json)?;
Self::from_json_value(&v, ignore)
}
fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
Ok(pbrs::json::int64(self.value()))
}
fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
let mut msg = Self::new();
msg.set_value(pbrs::json::as_i64(v)?);
Ok(msg)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
Ok(out)
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
Ok(out)
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
Self::from_text_value(&pbrs::text::parse(text)?)
}
fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
if self.value() != 0 {
pbrs::text::write_named_int64(out, indent, "value", self.value());
}
Ok(())
}
fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
let mut msg = Self::new();
for (key, val) in fields {
match key.as_str() {
"value" => {
msg.set_value(val.as_i64()?);
}
_ => return Err(ParseError::owned(format!("unknown field {key}"))),
}
}
Ok(msg)
}
}
pbrs::impl_typed_message!(Int64Value, Int64ValueView, Int64ValueMut);
#[derive(Clone, Debug)]
pub struct StringValue {
value: pbrs::rt::LazyStr,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for StringValue {
fn eq(&self, other: &Self) -> bool {
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for StringValue {}
impl Default for StringValue {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl StringValue {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.StringValue";
pub fn value(&self) -> &pbrs::ProtoStr {
self.value.as_view()
}
pub fn set_value(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
self.cached_size.dirty();
self.value = pbrs::rt::LazyStr::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.value = 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)?),
},
_ => 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)?,
},
_ => 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.value.is_empty() {
n += pbrs::rt::key_len_value_len(1, 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.value.is_empty() {
pbrs::rt::encode_len_field(out, 1, self.value.as_bytes());
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
Ok(self.to_json_value()?.to_string())
}
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 v = pbrs::json::parse(json)?;
Self::from_json_value(&v, ignore)
}
fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
Ok(pbrs::json::string(self.value().as_bytes()))
}
fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
let mut msg = Self::new();
msg.set_value(pbrs::json::as_str(v)?);
Ok(msg)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
Ok(out)
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
Ok(out)
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
Self::from_text_value(&pbrs::text::parse(text)?)
}
fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
if !self.value().as_bytes().is_empty() {
pbrs::text::write_named_string(out, indent, "value", self.value().as_bytes());
}
Ok(())
}
fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
let mut msg = Self::new();
for (key, val) in fields {
match key.as_str() {
"value" => {
msg.set_value(val.as_str()?);
}
_ => return Err(ParseError::owned(format!("unknown field {key}"))),
}
}
Ok(msg)
}
}
pbrs::impl_typed_message!(StringValue, StringValueView, StringValueMut);
#[derive(Clone, Debug)]
pub struct UInt32Value {
value: u32,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for UInt32Value {
fn eq(&self, other: &Self) -> bool {
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for UInt32Value {}
impl Default for UInt32Value {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl UInt32Value {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.UInt32Value";
pub fn value(&self) -> u32 {
self.value
}
pub fn set_value(&mut self, v: u32) {
self.cached_size.dirty();
self.value = 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_VARINT => {
self.value = pbrs::rt::decode_varint(data, pos)? as u32;
}
_ => 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 u32;
}
_ => 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.value != 0 {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len((self.value) as u64);
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if self.value != 0 {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, self.value as u64);
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
Ok(self.to_json_value()?.to_string())
}
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 v = pbrs::json::parse(json)?;
Self::from_json_value(&v, ignore)
}
fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
Ok(pbrs::json::uint32(self.value()))
}
fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
let mut msg = Self::new();
msg.set_value(pbrs::json::as_u32(v)?);
Ok(msg)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
Ok(out)
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
Ok(out)
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
Self::from_text_value(&pbrs::text::parse(text)?)
}
fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
if self.value() != 0 {
pbrs::text::write_named_uint32(out, indent, "value", self.value());
}
Ok(())
}
fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
let mut msg = Self::new();
for (key, val) in fields {
match key.as_str() {
"value" => {
msg.set_value(val.as_u32()?);
}
_ => return Err(ParseError::owned(format!("unknown field {key}"))),
}
}
Ok(msg)
}
}
pbrs::impl_typed_message!(UInt32Value, UInt32ValueView, UInt32ValueMut);
#[derive(Clone, Debug)]
pub struct UInt64Value {
value: u64,
unknown: UnknownFields,
cached_size: pbrs::rt::CachedSize,
}
impl PartialEq for UInt64Value {
fn eq(&self, other: &Self) -> bool {
if self.value != other.value {
return false;
}
self.unknown == other.unknown
}
}
impl Eq for UInt64Value {}
impl Default for UInt64Value {
#[inline(always)]
fn default() -> Self {
unsafe { pbrs::rt::zeroed_message() }
}
}
impl UInt64Value {
pub fn new() -> Self {
Self::default()
}
pub const EMPTY_PARSE_OK: bool = true;
pub const FULL_NAME: &'static str = "google.protobuf.UInt64Value";
pub fn value(&self) -> u64 {
self.value
}
pub fn set_value(&mut self, v: u64) {
self.cached_size.dirty();
self.value = 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_VARINT => {
self.value = pbrs::rt::decode_varint(data, pos)?;
}
_ => 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)?;
}
_ => 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.value != 0 {
n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
+ pbrs::rt::varint_len((self.value) as u64);
}
self.cached_size.set(n);
n
}
fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
if self.value != 0 {
pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
pbrs::rt::encode_varint(out, self.value as u64);
}
self.unknown.encode(out);
}
pub fn to_json(&self) -> Result<String, SerializeError> {
Ok(self.to_json_value()?.to_string())
}
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 v = pbrs::json::parse(json)?;
Self::from_json_value(&v, ignore)
}
fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
Ok(pbrs::json::uint64(self.value()))
}
fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
let mut msg = Self::new();
msg.set_value(pbrs::json::as_u64(v)?);
Ok(msg)
}
pub fn to_text(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
Ok(out)
}
pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
let mut out = String::new();
self.write_text(&mut out, 0)?;
pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
Ok(out)
}
pub fn from_text(text: &str) -> Result<Self, ParseError> {
Self::from_text_value(&pbrs::text::parse(text)?)
}
fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
if self.value() != 0 {
pbrs::text::write_named_uint64(out, indent, "value", self.value());
}
Ok(())
}
fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
let mut msg = Self::new();
for (key, val) in fields {
match key.as_str() {
"value" => {
msg.set_value(val.as_u64()?);
}
_ => return Err(ParseError::owned(format!("unknown field {key}"))),
}
}
Ok(msg)
}
}
pbrs::impl_typed_message!(UInt64Value, UInt64ValueView, UInt64ValueMut);
}
#[allow(unused_imports, reason = "generated by protoc-gen-pbrs")]
pub use __gen::*;