// @generated by protoc-gen-roto — do not edit #[allow(unused)] use crate::runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator}; use std::str; use bytes::{Bytes, BytesMut, Buf, BufMut}; use tonic::{Request, Response, Status}; use tokio_stream::Stream; use std::pin::Pin; use std::sync::Arc; use std::task::{Context, Poll}; use std::future::Future; use tonic::body::BoxBody; use tower::Service; use futures_util::StreamExt; use http_body_util::BodyExt; use http_body::Body; use roto_tonic::{BufferPool, StatusBody}; #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum Edition { EDITIONUNKNOWN = 0, EDITIONLEGACY = 900, EDITIONPROTO2 = 998, EDITIONPROTO3 = 999, EDITION2023 = 1000, EDITION2024 = 1001, EDITION2026 = 1002, EDITIONUNSTABLE = 9999, EDITION1TESTONLY = 1, EDITION2TESTONLY = 2, EDITION99997TESTONLY = 99997, EDITION99998TESTONLY = 99998, EDITION99999TESTONLY = 99999, EDITIONMAX = 2147483647, } impl Edition { pub fn from_i32(value: i32) -> Self { match value { 0 => Edition::EDITIONUNKNOWN, 900 => Edition::EDITIONLEGACY, 998 => Edition::EDITIONPROTO2, 999 => Edition::EDITIONPROTO3, 1000 => Edition::EDITION2023, 1001 => Edition::EDITION2024, 1002 => Edition::EDITION2026, 9999 => Edition::EDITIONUNSTABLE, 1 => Edition::EDITION1TESTONLY, 2 => Edition::EDITION2TESTONLY, 99997 => Edition::EDITION99997TESTONLY, 99998 => Edition::EDITION99998TESTONLY, 99999 => Edition::EDITION99999TESTONLY, 2147483647 => Edition::EDITIONMAX, _ => Edition::EDITIONUNKNOWN, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum SymbolVisibility { VISIBILITYUNSET = 0, VISIBILITYLOCAL = 1, VISIBILITYEXPORT = 2, } impl SymbolVisibility { pub fn from_i32(value: i32) -> Self { match value { 0 => SymbolVisibility::VISIBILITYUNSET, 1 => SymbolVisibility::VISIBILITYLOCAL, 2 => SymbolVisibility::VISIBILITYEXPORT, _ => SymbolVisibility::VISIBILITYUNSET, } } } pub struct FileDescriptorSet<'a> { accessor: crate::runtime::ProtoAccessor<'a>, file_start: Option, file_end: Option, } impl<'a> FileDescriptorSet<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut file_start = None; let mut file_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { if file_start.is_none() { file_start = Some(offset); } file_end = Some(offset); } } Ok(Self { accessor, file_start, file_end, }) } pub fn file(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.file_start, self.file_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(1, start, end), _ => self.accessor.iter_repeated(1), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FileDescriptorSetBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, file_written: bool, } impl<'b> FileDescriptorSetBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileDescriptorSetBuilder<'_> { FileDescriptorSetBuilder { builder: crate::runtime::ProtoBuilder::new(buf), file_written: false, } } pub fn file(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(1, value)?; self.file_written = true; Ok(self) } pub fn with(mut self, msg: &FileDescriptorSet<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.file_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedFileDescriptorSet { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedFileDescriptorSet { type Reader<'a> = FileDescriptorSet<'a>; fn reader(&self) -> FileDescriptorSet<'_> { FileDescriptorSet::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedFileDescriptorSet { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedFileDescriptorSet { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct FileDescriptorProto<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_offset: Option, package_offset: Option, dependency_start: Option, dependency_end: Option, public_dependency_start: Option, public_dependency_end: Option, weak_dependency_start: Option, weak_dependency_end: Option, option_dependency_start: Option, option_dependency_end: Option, message_type_start: Option, message_type_end: Option, enum_type_start: Option, enum_type_end: Option, service_start: Option, service_end: Option, extension_start: Option, extension_end: Option, options_offset: Option, source_code_info_offset: Option, syntax_offset: Option, edition_offset: Option, } impl<'a> FileDescriptorProto<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut package_offset = None; let mut dependency_start = None; let mut dependency_end = None; let mut public_dependency_start = None; let mut public_dependency_end = None; let mut weak_dependency_start = None; let mut weak_dependency_end = None; let mut option_dependency_start = None; let mut option_dependency_end = None; let mut message_type_start = None; let mut message_type_end = None; let mut enum_type_start = None; let mut enum_type_end = None; let mut service_start = None; let mut service_end = None; let mut extension_start = None; let mut extension_end = None; let mut options_offset = None; let mut source_code_info_offset = None; let mut syntax_offset = None; let mut edition_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { name_offset = Some(offset); } if tag.field_number == 2 { package_offset = Some(offset); } if tag.field_number == 3 { if dependency_start.is_none() { dependency_start = Some(offset); } dependency_end = Some(offset); } if tag.field_number == 10 { if public_dependency_start.is_none() { public_dependency_start = Some(offset); } public_dependency_end = Some(offset); } if tag.field_number == 11 { if weak_dependency_start.is_none() { weak_dependency_start = Some(offset); } weak_dependency_end = Some(offset); } if tag.field_number == 15 { if option_dependency_start.is_none() { option_dependency_start = Some(offset); } option_dependency_end = Some(offset); } if tag.field_number == 4 { if message_type_start.is_none() { message_type_start = Some(offset); } message_type_end = Some(offset); } if tag.field_number == 5 { if enum_type_start.is_none() { enum_type_start = Some(offset); } enum_type_end = Some(offset); } if tag.field_number == 6 { if service_start.is_none() { service_start = Some(offset); } service_end = Some(offset); } if tag.field_number == 7 { if extension_start.is_none() { extension_start = Some(offset); } extension_end = Some(offset); } if tag.field_number == 8 { options_offset = Some(offset); } if tag.field_number == 9 { source_code_info_offset = Some(offset); } if tag.field_number == 12 { syntax_offset = Some(offset); } if tag.field_number == 14 { edition_offset = Some(offset); } } Ok(Self { accessor, name_offset, package_offset, dependency_start, dependency_end, public_dependency_start, public_dependency_end, weak_dependency_start, weak_dependency_end, option_dependency_start, option_dependency_end, message_type_start, message_type_end, enum_type_start, enum_type_end, service_start, service_end, extension_start, extension_end, options_offset, source_code_info_offset, syntax_offset, edition_offset, }) } pub fn name(&self) -> crate::runtime::Result<&'a str> { let offset = self.name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn name_or_default(&self) -> crate::runtime::Result<&'a str> { self.name().or(Ok("")) } pub fn has_name(&self) -> bool { self.name_offset.is_some() } pub fn package(&self) -> crate::runtime::Result<&'a str> { let offset = self.package_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn package_or_default(&self) -> crate::runtime::Result<&'a str> { self.package().or(Ok("")) } pub fn has_package(&self) -> bool { self.package_offset.is_some() } pub fn dependency(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.dependency_start, self.dependency_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(3, start, end), _ => self.accessor.iter_repeated(3), } } pub fn public_dependency(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.public_dependency_start, self.public_dependency_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(10, start, end), _ => self.accessor.iter_repeated(10), } } pub fn weak_dependency(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.weak_dependency_start, self.weak_dependency_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(11, start, end), _ => self.accessor.iter_repeated(11), } } pub fn option_dependency(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.option_dependency_start, self.option_dependency_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(15, start, end), _ => self.accessor.iter_repeated(15), } } pub fn message_type(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.message_type_start, self.message_type_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(4, start, end), _ => self.accessor.iter_repeated(4), } } pub fn enum_type(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.enum_type_start, self.enum_type_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(5, start, end), _ => self.accessor.iter_repeated(5), } } pub fn service(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.service_start, self.service_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(6, start, end), _ => self.accessor.iter_repeated(6), } } pub fn extension(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.extension_start, self.extension_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(7, start, end), _ => self.accessor.iter_repeated(7), } } pub fn options(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.options_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn options_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.options().or(Ok(&[])) } pub fn has_options(&self) -> bool { self.options_offset.is_some() } pub fn source_code_info(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.source_code_info_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn source_code_info_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.source_code_info().or(Ok(&[])) } pub fn has_source_code_info(&self) -> bool { self.source_code_info_offset.is_some() } pub fn syntax(&self) -> crate::runtime::Result<&'a str> { let offset = self.syntax_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn syntax_or_default(&self) -> crate::runtime::Result<&'a str> { self.syntax().or(Ok("")) } pub fn has_syntax(&self) -> bool { self.syntax_offset.is_some() } pub fn edition(&self) -> crate::runtime::Result { let offset = self.edition_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn edition_or_default(&self) -> crate::runtime::Result { self.edition().or(Ok(0)) } pub fn has_edition(&self) -> bool { self.edition_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FileDescriptorProtoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_written: bool, package_written: bool, dependency_written: bool, public_dependency_written: bool, weak_dependency_written: bool, option_dependency_written: bool, message_type_written: bool, enum_type_written: bool, service_written: bool, extension_written: bool, options_written: bool, source_code_info_written: bool, syntax_written: bool, edition_written: bool, } impl<'b> FileDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileDescriptorProtoBuilder<'_> { FileDescriptorProtoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_written: false, package_written: false, dependency_written: false, public_dependency_written: false, weak_dependency_written: false, option_dependency_written: false, message_type_written: false, enum_type_written: false, service_written: false, extension_written: false, options_written: false, source_code_info_written: false, syntax_written: false, edition_written: false, } } pub fn name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } pub fn package(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(2, value)?; self.package_written = true; Ok(self) } pub fn dependency(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(3, value)?; self.dependency_written = true; Ok(self) } pub fn public_dependency(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(10, value)?; self.public_dependency_written = true; Ok(self) } pub fn weak_dependency(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(11, value)?; self.weak_dependency_written = true; Ok(self) } pub fn option_dependency(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(15, value)?; self.option_dependency_written = true; Ok(self) } pub fn message_type(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(4, value)?; self.message_type_written = true; Ok(self) } pub fn enum_type(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(5, value)?; self.enum_type_written = true; Ok(self) } pub fn service(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(6, value)?; self.service_written = true; Ok(self) } pub fn extension(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(7, value)?; self.extension_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(8, value)?; self.options_written = true; Ok(self) } pub fn source_code_info(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(9, value)?; self.source_code_info_written = true; Ok(self) } pub fn syntax(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(12, value)?; self.syntax_written = true; Ok(self) } pub fn edition(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(14, value)?; self.edition_written = true; Ok(self) } pub fn with(mut self, msg: &FileDescriptorProto<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, 2 => self.package_written, 3 => self.dependency_written, 10 => self.public_dependency_written, 11 => self.weak_dependency_written, 15 => self.option_dependency_written, 4 => self.message_type_written, 5 => self.enum_type_written, 6 => self.service_written, 7 => self.extension_written, 8 => self.options_written, 9 => self.source_code_info_written, 12 => self.syntax_written, 14 => self.edition_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedFileDescriptorProto { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedFileDescriptorProto { type Reader<'a> = FileDescriptorProto<'a>; fn reader(&self) -> FileDescriptorProto<'_> { FileDescriptorProto::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedFileDescriptorProto { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedFileDescriptorProto { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct DescriptorProto<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_offset: Option, field_start: Option, field_end: Option, extension_start: Option, extension_end: Option, nested_type_start: Option, nested_type_end: Option, enum_type_start: Option, enum_type_end: Option, extension_range_start: Option, extension_range_end: Option, oneof_decl_start: Option, oneof_decl_end: Option, options_offset: Option, reserved_range_start: Option, reserved_range_end: Option, reserved_name_start: Option, reserved_name_end: Option, visibility_offset: Option, } impl<'a> DescriptorProto<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut field_start = None; let mut field_end = None; let mut extension_start = None; let mut extension_end = None; let mut nested_type_start = None; let mut nested_type_end = None; let mut enum_type_start = None; let mut enum_type_end = None; let mut extension_range_start = None; let mut extension_range_end = None; let mut oneof_decl_start = None; let mut oneof_decl_end = None; let mut options_offset = None; let mut reserved_range_start = None; let mut reserved_range_end = None; let mut reserved_name_start = None; let mut reserved_name_end = None; let mut visibility_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { name_offset = Some(offset); } if tag.field_number == 2 { if field_start.is_none() { field_start = Some(offset); } field_end = Some(offset); } if tag.field_number == 6 { if extension_start.is_none() { extension_start = Some(offset); } extension_end = Some(offset); } if tag.field_number == 3 { if nested_type_start.is_none() { nested_type_start = Some(offset); } nested_type_end = Some(offset); } if tag.field_number == 4 { if enum_type_start.is_none() { enum_type_start = Some(offset); } enum_type_end = Some(offset); } if tag.field_number == 5 { if extension_range_start.is_none() { extension_range_start = Some(offset); } extension_range_end = Some(offset); } if tag.field_number == 8 { if oneof_decl_start.is_none() { oneof_decl_start = Some(offset); } oneof_decl_end = Some(offset); } if tag.field_number == 7 { options_offset = Some(offset); } if tag.field_number == 9 { if reserved_range_start.is_none() { reserved_range_start = Some(offset); } reserved_range_end = Some(offset); } if tag.field_number == 10 { if reserved_name_start.is_none() { reserved_name_start = Some(offset); } reserved_name_end = Some(offset); } if tag.field_number == 11 { visibility_offset = Some(offset); } } Ok(Self { accessor, name_offset, field_start, field_end, extension_start, extension_end, nested_type_start, nested_type_end, enum_type_start, enum_type_end, extension_range_start, extension_range_end, oneof_decl_start, oneof_decl_end, options_offset, reserved_range_start, reserved_range_end, reserved_name_start, reserved_name_end, visibility_offset, }) } pub fn name(&self) -> crate::runtime::Result<&'a str> { let offset = self.name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn name_or_default(&self) -> crate::runtime::Result<&'a str> { self.name().or(Ok("")) } pub fn has_name(&self) -> bool { self.name_offset.is_some() } pub fn field(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.field_start, self.field_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(2, start, end), _ => self.accessor.iter_repeated(2), } } pub fn extension(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.extension_start, self.extension_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(6, start, end), _ => self.accessor.iter_repeated(6), } } pub fn nested_type(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.nested_type_start, self.nested_type_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(3, start, end), _ => self.accessor.iter_repeated(3), } } pub fn enum_type(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.enum_type_start, self.enum_type_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(4, start, end), _ => self.accessor.iter_repeated(4), } } pub fn extension_range(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.extension_range_start, self.extension_range_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(5, start, end), _ => self.accessor.iter_repeated(5), } } pub fn oneof_decl(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.oneof_decl_start, self.oneof_decl_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(8, start, end), _ => self.accessor.iter_repeated(8), } } pub fn options(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.options_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn options_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.options().or(Ok(&[])) } pub fn has_options(&self) -> bool { self.options_offset.is_some() } pub fn reserved_range(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.reserved_range_start, self.reserved_range_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(9, start, end), _ => self.accessor.iter_repeated(9), } } pub fn reserved_name(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.reserved_name_start, self.reserved_name_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(10, start, end), _ => self.accessor.iter_repeated(10), } } pub fn visibility(&self) -> crate::runtime::Result { let offset = self.visibility_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn visibility_or_default(&self) -> crate::runtime::Result { self.visibility().or(Ok(0)) } pub fn has_visibility(&self) -> bool { self.visibility_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct DescriptorProtoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_written: bool, field_written: bool, extension_written: bool, nested_type_written: bool, enum_type_written: bool, extension_range_written: bool, oneof_decl_written: bool, options_written: bool, reserved_range_written: bool, reserved_name_written: bool, visibility_written: bool, } impl<'b> DescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> DescriptorProtoBuilder<'_> { DescriptorProtoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_written: false, field_written: false, extension_written: false, nested_type_written: false, enum_type_written: false, extension_range_written: false, oneof_decl_written: false, options_written: false, reserved_range_written: false, reserved_name_written: false, visibility_written: false, } } pub fn name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } pub fn field(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(2, value)?; self.field_written = true; Ok(self) } pub fn extension(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(6, value)?; self.extension_written = true; Ok(self) } pub fn nested_type(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(3, value)?; self.nested_type_written = true; Ok(self) } pub fn enum_type(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(4, value)?; self.enum_type_written = true; Ok(self) } pub fn extension_range(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(5, value)?; self.extension_range_written = true; Ok(self) } pub fn oneof_decl(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(8, value)?; self.oneof_decl_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(7, value)?; self.options_written = true; Ok(self) } pub fn reserved_range(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(9, value)?; self.reserved_range_written = true; Ok(self) } pub fn reserved_name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(10, value)?; self.reserved_name_written = true; Ok(self) } pub fn visibility(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(11, value)?; self.visibility_written = true; Ok(self) } pub fn with(mut self, msg: &DescriptorProto<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, 2 => self.field_written, 6 => self.extension_written, 3 => self.nested_type_written, 4 => self.enum_type_written, 5 => self.extension_range_written, 8 => self.oneof_decl_written, 7 => self.options_written, 9 => self.reserved_range_written, 10 => self.reserved_name_written, 11 => self.visibility_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedDescriptorProto { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedDescriptorProto { type Reader<'a> = DescriptorProto<'a>; fn reader(&self) -> DescriptorProto<'_> { DescriptorProto::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedDescriptorProto { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedDescriptorProto { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod descriptor_proto { pub struct ExtensionRange<'a> { accessor: crate::runtime::ProtoAccessor<'a>, start_offset: Option, end_offset: Option, options_offset: Option, } impl<'a> ExtensionRange<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut start_offset = None; let mut end_offset = None; let mut options_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { start_offset = Some(offset); } if tag.field_number == 2 { end_offset = Some(offset); } if tag.field_number == 3 { options_offset = Some(offset); } } Ok(Self { accessor, start_offset, end_offset, options_offset, }) } pub fn start(&self) -> crate::runtime::Result { let offset = self.start_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn start_or_default(&self) -> crate::runtime::Result { self.start().or(Ok(0)) } pub fn has_start(&self) -> bool { self.start_offset.is_some() } pub fn end(&self) -> crate::runtime::Result { let offset = self.end_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn end_or_default(&self) -> crate::runtime::Result { self.end().or(Ok(0)) } pub fn has_end(&self) -> bool { self.end_offset.is_some() } pub fn options(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.options_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn options_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.options().or(Ok(&[])) } pub fn has_options(&self) -> bool { self.options_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ExtensionRangeBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, start_written: bool, end_written: bool, options_written: bool, } impl<'b> ExtensionRangeBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ExtensionRangeBuilder<'_> { ExtensionRangeBuilder { builder: crate::runtime::ProtoBuilder::new(buf), start_written: false, end_written: false, options_written: false, } } pub fn start(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(1, value)?; self.start_written = true; Ok(self) } pub fn end(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(2, value)?; self.end_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(3, value)?; self.options_written = true; Ok(self) } pub fn with(mut self, msg: &ExtensionRange<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.start_written, 2 => self.end_written, 3 => self.options_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedExtensionRange { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedExtensionRange { type Reader<'a> = ExtensionRange<'a>; fn reader(&self) -> ExtensionRange<'_> { ExtensionRange::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedExtensionRange { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedExtensionRange { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct ReservedRange<'a> { accessor: crate::runtime::ProtoAccessor<'a>, start_offset: Option, end_offset: Option, } impl<'a> ReservedRange<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut start_offset = None; let mut end_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { start_offset = Some(offset); } if tag.field_number == 2 { end_offset = Some(offset); } } Ok(Self { accessor, start_offset, end_offset, }) } pub fn start(&self) -> crate::runtime::Result { let offset = self.start_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn start_or_default(&self) -> crate::runtime::Result { self.start().or(Ok(0)) } pub fn has_start(&self) -> bool { self.start_offset.is_some() } pub fn end(&self) -> crate::runtime::Result { let offset = self.end_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn end_or_default(&self) -> crate::runtime::Result { self.end().or(Ok(0)) } pub fn has_end(&self) -> bool { self.end_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ReservedRangeBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, start_written: bool, end_written: bool, } impl<'b> ReservedRangeBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ReservedRangeBuilder<'_> { ReservedRangeBuilder { builder: crate::runtime::ProtoBuilder::new(buf), start_written: false, end_written: false, } } pub fn start(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(1, value)?; self.start_written = true; Ok(self) } pub fn end(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(2, value)?; self.end_written = true; Ok(self) } pub fn with(mut self, msg: &ReservedRange<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.start_written, 2 => self.end_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedReservedRange { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedReservedRange { type Reader<'a> = ReservedRange<'a>; fn reader(&self) -> ReservedRange<'_> { ReservedRange::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedReservedRange { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedReservedRange { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } } pub struct ExtensionRangeOptions<'a> { accessor: crate::runtime::ProtoAccessor<'a>, uninterpreted_option_start: Option, uninterpreted_option_end: Option, declaration_start: Option, declaration_end: Option, features_offset: Option, verification_offset: Option, } impl<'a> ExtensionRangeOptions<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; let mut declaration_start = None; let mut declaration_end = None; let mut features_offset = None; let mut verification_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 999 { if uninterpreted_option_start.is_none() { uninterpreted_option_start = Some(offset); } uninterpreted_option_end = Some(offset); } if tag.field_number == 2 { if declaration_start.is_none() { declaration_start = Some(offset); } declaration_end = Some(offset); } if tag.field_number == 50 { features_offset = Some(offset); } if tag.field_number == 3 { verification_offset = Some(offset); } } Ok(Self { accessor, uninterpreted_option_start, uninterpreted_option_end, declaration_start, declaration_end, features_offset, verification_offset, }) } pub fn uninterpreted_option(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.uninterpreted_option_start, self.uninterpreted_option_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(999, start, end), _ => self.accessor.iter_repeated(999), } } pub fn declaration(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.declaration_start, self.declaration_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(2, start, end), _ => self.accessor.iter_repeated(2), } } pub fn features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.features().or(Ok(&[])) } pub fn has_features(&self) -> bool { self.features_offset.is_some() } pub fn verification(&self) -> crate::runtime::Result { let offset = self.verification_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn verification_or_default(&self) -> crate::runtime::Result { self.verification().or(Ok(0)) } pub fn has_verification(&self) -> bool { self.verification_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ExtensionRangeOptionsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, uninterpreted_option_written: bool, declaration_written: bool, features_written: bool, verification_written: bool, } impl<'b> ExtensionRangeOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ExtensionRangeOptionsBuilder<'_> { ExtensionRangeOptionsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), uninterpreted_option_written: false, declaration_written: false, features_written: false, verification_written: false, } } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } pub fn declaration(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(2, value)?; self.declaration_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(50, value)?; self.features_written = true; Ok(self) } pub fn verification(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(3, value)?; self.verification_written = true; Ok(self) } pub fn with(mut self, msg: &ExtensionRangeOptions<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 999 => self.uninterpreted_option_written, 2 => self.declaration_written, 50 => self.features_written, 3 => self.verification_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedExtensionRangeOptions { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedExtensionRangeOptions { type Reader<'a> = ExtensionRangeOptions<'a>; fn reader(&self) -> ExtensionRangeOptions<'_> { ExtensionRangeOptions::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedExtensionRangeOptions { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedExtensionRangeOptions { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod extension_range_options { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum VerificationState { DECLARATION = 0, UNVERIFIED = 1, } impl VerificationState { pub fn from_i32(value: i32) -> Self { match value { 0 => VerificationState::DECLARATION, 1 => VerificationState::UNVERIFIED, _ => VerificationState::DECLARATION, } } } pub struct Declaration<'a> { accessor: crate::runtime::ProtoAccessor<'a>, number_offset: Option, full_name_offset: Option, type_offset: Option, reserved_offset: Option, repeated_offset: Option, } impl<'a> Declaration<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut number_offset = None; let mut full_name_offset = None; let mut type_offset = None; let mut reserved_offset = None; let mut repeated_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { number_offset = Some(offset); } if tag.field_number == 2 { full_name_offset = Some(offset); } if tag.field_number == 3 { type_offset = Some(offset); } if tag.field_number == 5 { reserved_offset = Some(offset); } if tag.field_number == 6 { repeated_offset = Some(offset); } } Ok(Self { accessor, number_offset, full_name_offset, type_offset, reserved_offset, repeated_offset, }) } pub fn number(&self) -> crate::runtime::Result { let offset = self.number_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn number_or_default(&self) -> crate::runtime::Result { self.number().or(Ok(0)) } pub fn has_number(&self) -> bool { self.number_offset.is_some() } pub fn full_name(&self) -> crate::runtime::Result<&'a str> { let offset = self.full_name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn full_name_or_default(&self) -> crate::runtime::Result<&'a str> { self.full_name().or(Ok("")) } pub fn has_full_name(&self) -> bool { self.full_name_offset.is_some() } pub fn r#type(&self) -> crate::runtime::Result<&'a str> { let offset = self.type_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn r#type_or_default(&self) -> crate::runtime::Result<&'a str> { self.r#type().or(Ok("")) } pub fn has_type(&self) -> bool { self.type_offset.is_some() } pub fn reserved(&self) -> crate::runtime::Result { let offset = self.reserved_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn reserved_or_default(&self) -> crate::runtime::Result { self.reserved().or(Ok(false)) } pub fn has_reserved(&self) -> bool { self.reserved_offset.is_some() } pub fn repeated(&self) -> crate::runtime::Result { let offset = self.repeated_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn repeated_or_default(&self) -> crate::runtime::Result { self.repeated().or(Ok(false)) } pub fn has_repeated(&self) -> bool { self.repeated_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct DeclarationBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, number_written: bool, full_name_written: bool, type_written: bool, reserved_written: bool, repeated_written: bool, } impl<'b> DeclarationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> DeclarationBuilder<'_> { DeclarationBuilder { builder: crate::runtime::ProtoBuilder::new(buf), number_written: false, full_name_written: false, type_written: false, reserved_written: false, repeated_written: false, } } pub fn number(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(1, value)?; self.number_written = true; Ok(self) } pub fn full_name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(2, value)?; self.full_name_written = true; Ok(self) } pub fn r#type(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(3, value)?; self.type_written = true; Ok(self) } pub fn reserved(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(5, value)?; self.reserved_written = true; Ok(self) } pub fn repeated(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(6, value)?; self.repeated_written = true; Ok(self) } pub fn with(mut self, msg: &Declaration<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.number_written, 2 => self.full_name_written, 3 => self.type_written, 5 => self.reserved_written, 6 => self.repeated_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedDeclaration { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedDeclaration { type Reader<'a> = Declaration<'a>; fn reader(&self) -> Declaration<'_> { Declaration::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedDeclaration { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedDeclaration { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } } pub struct FieldDescriptorProto<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_offset: Option, number_offset: Option, label_offset: Option, type_offset: Option, type_name_offset: Option, extendee_offset: Option, default_value_offset: Option, oneof_index_offset: Option, json_name_offset: Option, options_offset: Option, proto3_optional_offset: Option, } impl<'a> FieldDescriptorProto<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut number_offset = None; let mut label_offset = None; let mut type_offset = None; let mut type_name_offset = None; let mut extendee_offset = None; let mut default_value_offset = None; let mut oneof_index_offset = None; let mut json_name_offset = None; let mut options_offset = None; let mut proto3_optional_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { name_offset = Some(offset); } if tag.field_number == 3 { number_offset = Some(offset); } if tag.field_number == 4 { label_offset = Some(offset); } if tag.field_number == 5 { type_offset = Some(offset); } if tag.field_number == 6 { type_name_offset = Some(offset); } if tag.field_number == 2 { extendee_offset = Some(offset); } if tag.field_number == 7 { default_value_offset = Some(offset); } if tag.field_number == 9 { oneof_index_offset = Some(offset); } if tag.field_number == 10 { json_name_offset = Some(offset); } if tag.field_number == 8 { options_offset = Some(offset); } if tag.field_number == 17 { proto3_optional_offset = Some(offset); } } Ok(Self { accessor, name_offset, number_offset, label_offset, type_offset, type_name_offset, extendee_offset, default_value_offset, oneof_index_offset, json_name_offset, options_offset, proto3_optional_offset, }) } pub fn name(&self) -> crate::runtime::Result<&'a str> { let offset = self.name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn name_or_default(&self) -> crate::runtime::Result<&'a str> { self.name().or(Ok("")) } pub fn has_name(&self) -> bool { self.name_offset.is_some() } pub fn number(&self) -> crate::runtime::Result { let offset = self.number_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn number_or_default(&self) -> crate::runtime::Result { self.number().or(Ok(0)) } pub fn has_number(&self) -> bool { self.number_offset.is_some() } pub fn label(&self) -> crate::runtime::Result { let offset = self.label_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn label_or_default(&self) -> crate::runtime::Result { self.label().or(Ok(0)) } pub fn has_label(&self) -> bool { self.label_offset.is_some() } pub fn r#type(&self) -> crate::runtime::Result { let offset = self.type_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn r#type_or_default(&self) -> crate::runtime::Result { self.r#type().or(Ok(0)) } pub fn has_type(&self) -> bool { self.type_offset.is_some() } pub fn type_name(&self) -> crate::runtime::Result<&'a str> { let offset = self.type_name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn type_name_or_default(&self) -> crate::runtime::Result<&'a str> { self.type_name().or(Ok("")) } pub fn has_type_name(&self) -> bool { self.type_name_offset.is_some() } pub fn extendee(&self) -> crate::runtime::Result<&'a str> { let offset = self.extendee_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn extendee_or_default(&self) -> crate::runtime::Result<&'a str> { self.extendee().or(Ok("")) } pub fn has_extendee(&self) -> bool { self.extendee_offset.is_some() } pub fn default_value(&self) -> crate::runtime::Result<&'a str> { let offset = self.default_value_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn default_value_or_default(&self) -> crate::runtime::Result<&'a str> { self.default_value().or(Ok("")) } pub fn has_default_value(&self) -> bool { self.default_value_offset.is_some() } pub fn oneof_index(&self) -> crate::runtime::Result { let offset = self.oneof_index_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn oneof_index_or_default(&self) -> crate::runtime::Result { self.oneof_index().or(Ok(0)) } pub fn has_oneof_index(&self) -> bool { self.oneof_index_offset.is_some() } pub fn json_name(&self) -> crate::runtime::Result<&'a str> { let offset = self.json_name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn json_name_or_default(&self) -> crate::runtime::Result<&'a str> { self.json_name().or(Ok("")) } pub fn has_json_name(&self) -> bool { self.json_name_offset.is_some() } pub fn options(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.options_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn options_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.options().or(Ok(&[])) } pub fn has_options(&self) -> bool { self.options_offset.is_some() } pub fn proto3_optional(&self) -> crate::runtime::Result { let offset = self.proto3_optional_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn proto3_optional_or_default(&self) -> crate::runtime::Result { self.proto3_optional().or(Ok(false)) } pub fn has_proto3_optional(&self) -> bool { self.proto3_optional_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FieldDescriptorProtoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_written: bool, number_written: bool, label_written: bool, type_written: bool, type_name_written: bool, extendee_written: bool, default_value_written: bool, oneof_index_written: bool, json_name_written: bool, options_written: bool, proto3_optional_written: bool, } impl<'b> FieldDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FieldDescriptorProtoBuilder<'_> { FieldDescriptorProtoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_written: false, number_written: false, label_written: false, type_written: false, type_name_written: false, extendee_written: false, default_value_written: false, oneof_index_written: false, json_name_written: false, options_written: false, proto3_optional_written: false, } } pub fn name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } pub fn number(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(3, value)?; self.number_written = true; Ok(self) } pub fn label(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(4, value)?; self.label_written = true; Ok(self) } pub fn r#type(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(5, value)?; self.type_written = true; Ok(self) } pub fn type_name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(6, value)?; self.type_name_written = true; Ok(self) } pub fn extendee(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(2, value)?; self.extendee_written = true; Ok(self) } pub fn default_value(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(7, value)?; self.default_value_written = true; Ok(self) } pub fn oneof_index(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(9, value)?; self.oneof_index_written = true; Ok(self) } pub fn json_name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(10, value)?; self.json_name_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(8, value)?; self.options_written = true; Ok(self) } pub fn proto3_optional(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(17, value)?; self.proto3_optional_written = true; Ok(self) } pub fn with(mut self, msg: &FieldDescriptorProto<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, 3 => self.number_written, 4 => self.label_written, 5 => self.type_written, 6 => self.type_name_written, 2 => self.extendee_written, 7 => self.default_value_written, 9 => self.oneof_index_written, 10 => self.json_name_written, 8 => self.options_written, 17 => self.proto3_optional_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedFieldDescriptorProto { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedFieldDescriptorProto { type Reader<'a> = FieldDescriptorProto<'a>; fn reader(&self) -> FieldDescriptorProto<'_> { FieldDescriptorProto::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedFieldDescriptorProto { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedFieldDescriptorProto { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod field_descriptor_proto { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum Type { TYPEDOUBLE = 1, TYPEFLOAT = 2, TYPEINT64 = 3, TYPEUINT64 = 4, TYPEINT32 = 5, TYPEFIXED64 = 6, TYPEFIXED32 = 7, TYPEBOOL = 8, TYPESTRING = 9, TYPEGROUP = 10, TYPEMESSAGE = 11, TYPEBYTES = 12, TYPEUINT32 = 13, TYPEENUM = 14, TYPESFIXED32 = 15, TYPESFIXED64 = 16, TYPESINT32 = 17, TYPESINT64 = 18, Unknown = 0, } impl Type { pub fn from_i32(value: i32) -> Self { match value { 1 => Type::TYPEDOUBLE, 2 => Type::TYPEFLOAT, 3 => Type::TYPEINT64, 4 => Type::TYPEUINT64, 5 => Type::TYPEINT32, 6 => Type::TYPEFIXED64, 7 => Type::TYPEFIXED32, 8 => Type::TYPEBOOL, 9 => Type::TYPESTRING, 10 => Type::TYPEGROUP, 11 => Type::TYPEMESSAGE, 12 => Type::TYPEBYTES, 13 => Type::TYPEUINT32, 14 => Type::TYPEENUM, 15 => Type::TYPESFIXED32, 16 => Type::TYPESFIXED64, 17 => Type::TYPESINT32, 18 => Type::TYPESINT64, _ => Type::Unknown, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum Label { LABELOPTIONAL = 1, LABELREPEATED = 3, LABELREQUIRED = 2, Unknown = 0, } impl Label { pub fn from_i32(value: i32) -> Self { match value { 1 => Label::LABELOPTIONAL, 3 => Label::LABELREPEATED, 2 => Label::LABELREQUIRED, _ => Label::Unknown, } } } } pub struct OneofDescriptorProto<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_offset: Option, options_offset: Option, } impl<'a> OneofDescriptorProto<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut options_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { name_offset = Some(offset); } if tag.field_number == 2 { options_offset = Some(offset); } } Ok(Self { accessor, name_offset, options_offset, }) } pub fn name(&self) -> crate::runtime::Result<&'a str> { let offset = self.name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn name_or_default(&self) -> crate::runtime::Result<&'a str> { self.name().or(Ok("")) } pub fn has_name(&self) -> bool { self.name_offset.is_some() } pub fn options(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.options_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn options_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.options().or(Ok(&[])) } pub fn has_options(&self) -> bool { self.options_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct OneofDescriptorProtoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_written: bool, options_written: bool, } impl<'b> OneofDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> OneofDescriptorProtoBuilder<'_> { OneofDescriptorProtoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_written: false, options_written: false, } } pub fn name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(2, value)?; self.options_written = true; Ok(self) } pub fn with(mut self, msg: &OneofDescriptorProto<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, 2 => self.options_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedOneofDescriptorProto { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedOneofDescriptorProto { type Reader<'a> = OneofDescriptorProto<'a>; fn reader(&self) -> OneofDescriptorProto<'_> { OneofDescriptorProto::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedOneofDescriptorProto { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedOneofDescriptorProto { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct EnumDescriptorProto<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_offset: Option, value_start: Option, value_end: Option, options_offset: Option, reserved_range_start: Option, reserved_range_end: Option, reserved_name_start: Option, reserved_name_end: Option, visibility_offset: Option, } impl<'a> EnumDescriptorProto<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut value_start = None; let mut value_end = None; let mut options_offset = None; let mut reserved_range_start = None; let mut reserved_range_end = None; let mut reserved_name_start = None; let mut reserved_name_end = None; let mut visibility_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { name_offset = Some(offset); } if tag.field_number == 2 { if value_start.is_none() { value_start = Some(offset); } value_end = Some(offset); } if tag.field_number == 3 { options_offset = Some(offset); } if tag.field_number == 4 { if reserved_range_start.is_none() { reserved_range_start = Some(offset); } reserved_range_end = Some(offset); } if tag.field_number == 5 { if reserved_name_start.is_none() { reserved_name_start = Some(offset); } reserved_name_end = Some(offset); } if tag.field_number == 6 { visibility_offset = Some(offset); } } Ok(Self { accessor, name_offset, value_start, value_end, options_offset, reserved_range_start, reserved_range_end, reserved_name_start, reserved_name_end, visibility_offset, }) } pub fn name(&self) -> crate::runtime::Result<&'a str> { let offset = self.name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn name_or_default(&self) -> crate::runtime::Result<&'a str> { self.name().or(Ok("")) } pub fn has_name(&self) -> bool { self.name_offset.is_some() } pub fn value(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.value_start, self.value_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(2, start, end), _ => self.accessor.iter_repeated(2), } } pub fn options(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.options_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn options_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.options().or(Ok(&[])) } pub fn has_options(&self) -> bool { self.options_offset.is_some() } pub fn reserved_range(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.reserved_range_start, self.reserved_range_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(4, start, end), _ => self.accessor.iter_repeated(4), } } pub fn reserved_name(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.reserved_name_start, self.reserved_name_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(5, start, end), _ => self.accessor.iter_repeated(5), } } pub fn visibility(&self) -> crate::runtime::Result { let offset = self.visibility_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn visibility_or_default(&self) -> crate::runtime::Result { self.visibility().or(Ok(0)) } pub fn has_visibility(&self) -> bool { self.visibility_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumDescriptorProtoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_written: bool, value_written: bool, options_written: bool, reserved_range_written: bool, reserved_name_written: bool, visibility_written: bool, } impl<'b> EnumDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumDescriptorProtoBuilder<'_> { EnumDescriptorProtoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_written: false, value_written: false, options_written: false, reserved_range_written: false, reserved_name_written: false, visibility_written: false, } } pub fn name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } pub fn value(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(2, value)?; self.value_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(3, value)?; self.options_written = true; Ok(self) } pub fn reserved_range(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(4, value)?; self.reserved_range_written = true; Ok(self) } pub fn reserved_name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(5, value)?; self.reserved_name_written = true; Ok(self) } pub fn visibility(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(6, value)?; self.visibility_written = true; Ok(self) } pub fn with(mut self, msg: &EnumDescriptorProto<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, 2 => self.value_written, 3 => self.options_written, 4 => self.reserved_range_written, 5 => self.reserved_name_written, 6 => self.visibility_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedEnumDescriptorProto { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedEnumDescriptorProto { type Reader<'a> = EnumDescriptorProto<'a>; fn reader(&self) -> EnumDescriptorProto<'_> { EnumDescriptorProto::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedEnumDescriptorProto { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedEnumDescriptorProto { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod enum_descriptor_proto { pub struct EnumReservedRange<'a> { accessor: crate::runtime::ProtoAccessor<'a>, start_offset: Option, end_offset: Option, } impl<'a> EnumReservedRange<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut start_offset = None; let mut end_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { start_offset = Some(offset); } if tag.field_number == 2 { end_offset = Some(offset); } } Ok(Self { accessor, start_offset, end_offset, }) } pub fn start(&self) -> crate::runtime::Result { let offset = self.start_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn start_or_default(&self) -> crate::runtime::Result { self.start().or(Ok(0)) } pub fn has_start(&self) -> bool { self.start_offset.is_some() } pub fn end(&self) -> crate::runtime::Result { let offset = self.end_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn end_or_default(&self) -> crate::runtime::Result { self.end().or(Ok(0)) } pub fn has_end(&self) -> bool { self.end_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumReservedRangeBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, start_written: bool, end_written: bool, } impl<'b> EnumReservedRangeBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumReservedRangeBuilder<'_> { EnumReservedRangeBuilder { builder: crate::runtime::ProtoBuilder::new(buf), start_written: false, end_written: false, } } pub fn start(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(1, value)?; self.start_written = true; Ok(self) } pub fn end(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(2, value)?; self.end_written = true; Ok(self) } pub fn with(mut self, msg: &EnumReservedRange<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.start_written, 2 => self.end_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedEnumReservedRange { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedEnumReservedRange { type Reader<'a> = EnumReservedRange<'a>; fn reader(&self) -> EnumReservedRange<'_> { EnumReservedRange::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedEnumReservedRange { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedEnumReservedRange { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } } pub struct EnumValueDescriptorProto<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_offset: Option, number_offset: Option, options_offset: Option, } impl<'a> EnumValueDescriptorProto<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut number_offset = None; let mut options_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { name_offset = Some(offset); } if tag.field_number == 2 { number_offset = Some(offset); } if tag.field_number == 3 { options_offset = Some(offset); } } Ok(Self { accessor, name_offset, number_offset, options_offset, }) } pub fn name(&self) -> crate::runtime::Result<&'a str> { let offset = self.name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn name_or_default(&self) -> crate::runtime::Result<&'a str> { self.name().or(Ok("")) } pub fn has_name(&self) -> bool { self.name_offset.is_some() } pub fn number(&self) -> crate::runtime::Result { let offset = self.number_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn number_or_default(&self) -> crate::runtime::Result { self.number().or(Ok(0)) } pub fn has_number(&self) -> bool { self.number_offset.is_some() } pub fn options(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.options_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn options_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.options().or(Ok(&[])) } pub fn has_options(&self) -> bool { self.options_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumValueDescriptorProtoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_written: bool, number_written: bool, options_written: bool, } impl<'b> EnumValueDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumValueDescriptorProtoBuilder<'_> { EnumValueDescriptorProtoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_written: false, number_written: false, options_written: false, } } pub fn name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } pub fn number(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(2, value)?; self.number_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(3, value)?; self.options_written = true; Ok(self) } pub fn with(mut self, msg: &EnumValueDescriptorProto<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, 2 => self.number_written, 3 => self.options_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedEnumValueDescriptorProto { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedEnumValueDescriptorProto { type Reader<'a> = EnumValueDescriptorProto<'a>; fn reader(&self) -> EnumValueDescriptorProto<'_> { EnumValueDescriptorProto::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedEnumValueDescriptorProto { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedEnumValueDescriptorProto { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct ServiceDescriptorProto<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_offset: Option, method_start: Option, method_end: Option, options_offset: Option, } impl<'a> ServiceDescriptorProto<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut method_start = None; let mut method_end = None; let mut options_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { name_offset = Some(offset); } if tag.field_number == 2 { if method_start.is_none() { method_start = Some(offset); } method_end = Some(offset); } if tag.field_number == 3 { options_offset = Some(offset); } } Ok(Self { accessor, name_offset, method_start, method_end, options_offset, }) } pub fn name(&self) -> crate::runtime::Result<&'a str> { let offset = self.name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn name_or_default(&self) -> crate::runtime::Result<&'a str> { self.name().or(Ok("")) } pub fn has_name(&self) -> bool { self.name_offset.is_some() } pub fn method(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.method_start, self.method_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(2, start, end), _ => self.accessor.iter_repeated(2), } } pub fn options(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.options_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn options_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.options().or(Ok(&[])) } pub fn has_options(&self) -> bool { self.options_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ServiceDescriptorProtoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_written: bool, method_written: bool, options_written: bool, } impl<'b> ServiceDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ServiceDescriptorProtoBuilder<'_> { ServiceDescriptorProtoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_written: false, method_written: false, options_written: false, } } pub fn name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } pub fn method(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(2, value)?; self.method_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(3, value)?; self.options_written = true; Ok(self) } pub fn with(mut self, msg: &ServiceDescriptorProto<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, 2 => self.method_written, 3 => self.options_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedServiceDescriptorProto { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedServiceDescriptorProto { type Reader<'a> = ServiceDescriptorProto<'a>; fn reader(&self) -> ServiceDescriptorProto<'_> { ServiceDescriptorProto::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedServiceDescriptorProto { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedServiceDescriptorProto { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct MethodDescriptorProto<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_offset: Option, input_type_offset: Option, output_type_offset: Option, options_offset: Option, client_streaming_offset: Option, server_streaming_offset: Option, } impl<'a> MethodDescriptorProto<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut input_type_offset = None; let mut output_type_offset = None; let mut options_offset = None; let mut client_streaming_offset = None; let mut server_streaming_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { name_offset = Some(offset); } if tag.field_number == 2 { input_type_offset = Some(offset); } if tag.field_number == 3 { output_type_offset = Some(offset); } if tag.field_number == 4 { options_offset = Some(offset); } if tag.field_number == 5 { client_streaming_offset = Some(offset); } if tag.field_number == 6 { server_streaming_offset = Some(offset); } } Ok(Self { accessor, name_offset, input_type_offset, output_type_offset, options_offset, client_streaming_offset, server_streaming_offset, }) } pub fn name(&self) -> crate::runtime::Result<&'a str> { let offset = self.name_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn name_or_default(&self) -> crate::runtime::Result<&'a str> { self.name().or(Ok("")) } pub fn has_name(&self) -> bool { self.name_offset.is_some() } pub fn input_type(&self) -> crate::runtime::Result<&'a str> { let offset = self.input_type_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn input_type_or_default(&self) -> crate::runtime::Result<&'a str> { self.input_type().or(Ok("")) } pub fn has_input_type(&self) -> bool { self.input_type_offset.is_some() } pub fn output_type(&self) -> crate::runtime::Result<&'a str> { let offset = self.output_type_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn output_type_or_default(&self) -> crate::runtime::Result<&'a str> { self.output_type().or(Ok("")) } pub fn has_output_type(&self) -> bool { self.output_type_offset.is_some() } pub fn options(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.options_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn options_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.options().or(Ok(&[])) } pub fn has_options(&self) -> bool { self.options_offset.is_some() } pub fn client_streaming(&self) -> crate::runtime::Result { let offset = self.client_streaming_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn client_streaming_or_default(&self) -> crate::runtime::Result { self.client_streaming().or(Ok(false)) } pub fn has_client_streaming(&self) -> bool { self.client_streaming_offset.is_some() } pub fn server_streaming(&self) -> crate::runtime::Result { let offset = self.server_streaming_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn server_streaming_or_default(&self) -> crate::runtime::Result { self.server_streaming().or(Ok(false)) } pub fn has_server_streaming(&self) -> bool { self.server_streaming_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct MethodDescriptorProtoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_written: bool, input_type_written: bool, output_type_written: bool, options_written: bool, client_streaming_written: bool, server_streaming_written: bool, } impl<'b> MethodDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> MethodDescriptorProtoBuilder<'_> { MethodDescriptorProtoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_written: false, input_type_written: false, output_type_written: false, options_written: false, client_streaming_written: false, server_streaming_written: false, } } pub fn name(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } pub fn input_type(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(2, value)?; self.input_type_written = true; Ok(self) } pub fn output_type(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(3, value)?; self.output_type_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(4, value)?; self.options_written = true; Ok(self) } pub fn client_streaming(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(5, value)?; self.client_streaming_written = true; Ok(self) } pub fn server_streaming(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(6, value)?; self.server_streaming_written = true; Ok(self) } pub fn with(mut self, msg: &MethodDescriptorProto<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, 2 => self.input_type_written, 3 => self.output_type_written, 4 => self.options_written, 5 => self.client_streaming_written, 6 => self.server_streaming_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedMethodDescriptorProto { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedMethodDescriptorProto { type Reader<'a> = MethodDescriptorProto<'a>; fn reader(&self) -> MethodDescriptorProto<'_> { MethodDescriptorProto::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedMethodDescriptorProto { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedMethodDescriptorProto { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct FileOptions<'a> { accessor: crate::runtime::ProtoAccessor<'a>, java_package_offset: Option, java_outer_classname_offset: Option, java_multiple_files_offset: Option, java_generate_equals_and_hash_offset: Option, java_string_check_utf8_offset: Option, optimize_for_offset: Option, go_package_offset: Option, cc_generic_services_offset: Option, java_generic_services_offset: Option, py_generic_services_offset: Option, deprecated_offset: Option, cc_enable_arenas_offset: Option, objc_class_prefix_offset: Option, csharp_namespace_offset: Option, swift_prefix_offset: Option, php_class_prefix_offset: Option, php_namespace_offset: Option, php_metadata_namespace_offset: Option, ruby_package_offset: Option, features_offset: Option, uninterpreted_option_start: Option, uninterpreted_option_end: Option, } impl<'a> FileOptions<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut java_package_offset = None; let mut java_outer_classname_offset = None; let mut java_multiple_files_offset = None; let mut java_generate_equals_and_hash_offset = None; let mut java_string_check_utf8_offset = None; let mut optimize_for_offset = None; let mut go_package_offset = None; let mut cc_generic_services_offset = None; let mut java_generic_services_offset = None; let mut py_generic_services_offset = None; let mut deprecated_offset = None; let mut cc_enable_arenas_offset = None; let mut objc_class_prefix_offset = None; let mut csharp_namespace_offset = None; let mut swift_prefix_offset = None; let mut php_class_prefix_offset = None; let mut php_namespace_offset = None; let mut php_metadata_namespace_offset = None; let mut ruby_package_offset = None; let mut features_offset = None; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { java_package_offset = Some(offset); } if tag.field_number == 8 { java_outer_classname_offset = Some(offset); } if tag.field_number == 10 { java_multiple_files_offset = Some(offset); } if tag.field_number == 20 { java_generate_equals_and_hash_offset = Some(offset); } if tag.field_number == 27 { java_string_check_utf8_offset = Some(offset); } if tag.field_number == 9 { optimize_for_offset = Some(offset); } if tag.field_number == 11 { go_package_offset = Some(offset); } if tag.field_number == 16 { cc_generic_services_offset = Some(offset); } if tag.field_number == 17 { java_generic_services_offset = Some(offset); } if tag.field_number == 18 { py_generic_services_offset = Some(offset); } if tag.field_number == 23 { deprecated_offset = Some(offset); } if tag.field_number == 31 { cc_enable_arenas_offset = Some(offset); } if tag.field_number == 36 { objc_class_prefix_offset = Some(offset); } if tag.field_number == 37 { csharp_namespace_offset = Some(offset); } if tag.field_number == 39 { swift_prefix_offset = Some(offset); } if tag.field_number == 40 { php_class_prefix_offset = Some(offset); } if tag.field_number == 41 { php_namespace_offset = Some(offset); } if tag.field_number == 44 { php_metadata_namespace_offset = Some(offset); } if tag.field_number == 45 { ruby_package_offset = Some(offset); } if tag.field_number == 50 { features_offset = Some(offset); } if tag.field_number == 999 { if uninterpreted_option_start.is_none() { uninterpreted_option_start = Some(offset); } uninterpreted_option_end = Some(offset); } } Ok(Self { accessor, java_package_offset, java_outer_classname_offset, java_multiple_files_offset, java_generate_equals_and_hash_offset, java_string_check_utf8_offset, optimize_for_offset, go_package_offset, cc_generic_services_offset, java_generic_services_offset, py_generic_services_offset, deprecated_offset, cc_enable_arenas_offset, objc_class_prefix_offset, csharp_namespace_offset, swift_prefix_offset, php_class_prefix_offset, php_namespace_offset, php_metadata_namespace_offset, ruby_package_offset, features_offset, uninterpreted_option_start, uninterpreted_option_end, }) } pub fn java_package(&self) -> crate::runtime::Result<&'a str> { let offset = self.java_package_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn java_package_or_default(&self) -> crate::runtime::Result<&'a str> { self.java_package().or(Ok("")) } pub fn has_java_package(&self) -> bool { self.java_package_offset.is_some() } pub fn java_outer_classname(&self) -> crate::runtime::Result<&'a str> { let offset = self.java_outer_classname_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn java_outer_classname_or_default(&self) -> crate::runtime::Result<&'a str> { self.java_outer_classname().or(Ok("")) } pub fn has_java_outer_classname(&self) -> bool { self.java_outer_classname_offset.is_some() } pub fn java_multiple_files(&self) -> crate::runtime::Result { let offset = self.java_multiple_files_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn java_multiple_files_or_default(&self) -> crate::runtime::Result { self.java_multiple_files().or(Ok(false)) } pub fn has_java_multiple_files(&self) -> bool { self.java_multiple_files_offset.is_some() } pub fn java_generate_equals_and_hash(&self) -> crate::runtime::Result { let offset = self.java_generate_equals_and_hash_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn java_generate_equals_and_hash_or_default(&self) -> crate::runtime::Result { self.java_generate_equals_and_hash().or(Ok(false)) } pub fn has_java_generate_equals_and_hash(&self) -> bool { self.java_generate_equals_and_hash_offset.is_some() } pub fn java_string_check_utf8(&self) -> crate::runtime::Result { let offset = self.java_string_check_utf8_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn java_string_check_utf8_or_default(&self) -> crate::runtime::Result { self.java_string_check_utf8().or(Ok(false)) } pub fn has_java_string_check_utf8(&self) -> bool { self.java_string_check_utf8_offset.is_some() } pub fn optimize_for(&self) -> crate::runtime::Result { let offset = self.optimize_for_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn optimize_for_or_default(&self) -> crate::runtime::Result { self.optimize_for().or(Ok(0)) } pub fn has_optimize_for(&self) -> bool { self.optimize_for_offset.is_some() } pub fn go_package(&self) -> crate::runtime::Result<&'a str> { let offset = self.go_package_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn go_package_or_default(&self) -> crate::runtime::Result<&'a str> { self.go_package().or(Ok("")) } pub fn has_go_package(&self) -> bool { self.go_package_offset.is_some() } pub fn cc_generic_services(&self) -> crate::runtime::Result { let offset = self.cc_generic_services_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn cc_generic_services_or_default(&self) -> crate::runtime::Result { self.cc_generic_services().or(Ok(false)) } pub fn has_cc_generic_services(&self) -> bool { self.cc_generic_services_offset.is_some() } pub fn java_generic_services(&self) -> crate::runtime::Result { let offset = self.java_generic_services_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn java_generic_services_or_default(&self) -> crate::runtime::Result { self.java_generic_services().or(Ok(false)) } pub fn has_java_generic_services(&self) -> bool { self.java_generic_services_offset.is_some() } pub fn py_generic_services(&self) -> crate::runtime::Result { let offset = self.py_generic_services_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn py_generic_services_or_default(&self) -> crate::runtime::Result { self.py_generic_services().or(Ok(false)) } pub fn has_py_generic_services(&self) -> bool { self.py_generic_services_offset.is_some() } pub fn deprecated(&self) -> crate::runtime::Result { let offset = self.deprecated_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecated_or_default(&self) -> crate::runtime::Result { self.deprecated().or(Ok(false)) } pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } pub fn cc_enable_arenas(&self) -> crate::runtime::Result { let offset = self.cc_enable_arenas_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn cc_enable_arenas_or_default(&self) -> crate::runtime::Result { self.cc_enable_arenas().or(Ok(false)) } pub fn has_cc_enable_arenas(&self) -> bool { self.cc_enable_arenas_offset.is_some() } pub fn objc_class_prefix(&self) -> crate::runtime::Result<&'a str> { let offset = self.objc_class_prefix_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn objc_class_prefix_or_default(&self) -> crate::runtime::Result<&'a str> { self.objc_class_prefix().or(Ok("")) } pub fn has_objc_class_prefix(&self) -> bool { self.objc_class_prefix_offset.is_some() } pub fn csharp_namespace(&self) -> crate::runtime::Result<&'a str> { let offset = self.csharp_namespace_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn csharp_namespace_or_default(&self) -> crate::runtime::Result<&'a str> { self.csharp_namespace().or(Ok("")) } pub fn has_csharp_namespace(&self) -> bool { self.csharp_namespace_offset.is_some() } pub fn swift_prefix(&self) -> crate::runtime::Result<&'a str> { let offset = self.swift_prefix_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn swift_prefix_or_default(&self) -> crate::runtime::Result<&'a str> { self.swift_prefix().or(Ok("")) } pub fn has_swift_prefix(&self) -> bool { self.swift_prefix_offset.is_some() } pub fn php_class_prefix(&self) -> crate::runtime::Result<&'a str> { let offset = self.php_class_prefix_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn php_class_prefix_or_default(&self) -> crate::runtime::Result<&'a str> { self.php_class_prefix().or(Ok("")) } pub fn has_php_class_prefix(&self) -> bool { self.php_class_prefix_offset.is_some() } pub fn php_namespace(&self) -> crate::runtime::Result<&'a str> { let offset = self.php_namespace_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn php_namespace_or_default(&self) -> crate::runtime::Result<&'a str> { self.php_namespace().or(Ok("")) } pub fn has_php_namespace(&self) -> bool { self.php_namespace_offset.is_some() } pub fn php_metadata_namespace(&self) -> crate::runtime::Result<&'a str> { let offset = self.php_metadata_namespace_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn php_metadata_namespace_or_default(&self) -> crate::runtime::Result<&'a str> { self.php_metadata_namespace().or(Ok("")) } pub fn has_php_metadata_namespace(&self) -> bool { self.php_metadata_namespace_offset.is_some() } pub fn ruby_package(&self) -> crate::runtime::Result<&'a str> { let offset = self.ruby_package_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn ruby_package_or_default(&self) -> crate::runtime::Result<&'a str> { self.ruby_package().or(Ok("")) } pub fn has_ruby_package(&self) -> bool { self.ruby_package_offset.is_some() } pub fn features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.features().or(Ok(&[])) } pub fn has_features(&self) -> bool { self.features_offset.is_some() } pub fn uninterpreted_option(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.uninterpreted_option_start, self.uninterpreted_option_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(999, start, end), _ => self.accessor.iter_repeated(999), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FileOptionsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, java_package_written: bool, java_outer_classname_written: bool, java_multiple_files_written: bool, java_generate_equals_and_hash_written: bool, java_string_check_utf8_written: bool, optimize_for_written: bool, go_package_written: bool, cc_generic_services_written: bool, java_generic_services_written: bool, py_generic_services_written: bool, deprecated_written: bool, cc_enable_arenas_written: bool, objc_class_prefix_written: bool, csharp_namespace_written: bool, swift_prefix_written: bool, php_class_prefix_written: bool, php_namespace_written: bool, php_metadata_namespace_written: bool, ruby_package_written: bool, features_written: bool, uninterpreted_option_written: bool, } impl<'b> FileOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileOptionsBuilder<'_> { FileOptionsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), java_package_written: false, java_outer_classname_written: false, java_multiple_files_written: false, java_generate_equals_and_hash_written: false, java_string_check_utf8_written: false, optimize_for_written: false, go_package_written: false, cc_generic_services_written: false, java_generic_services_written: false, py_generic_services_written: false, deprecated_written: false, cc_enable_arenas_written: false, objc_class_prefix_written: false, csharp_namespace_written: false, swift_prefix_written: false, php_class_prefix_written: false, php_namespace_written: false, php_metadata_namespace_written: false, ruby_package_written: false, features_written: false, uninterpreted_option_written: false, } } pub fn java_package(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.java_package_written = true; Ok(self) } pub fn java_outer_classname(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(8, value)?; self.java_outer_classname_written = true; Ok(self) } pub fn java_multiple_files(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(10, value)?; self.java_multiple_files_written = true; Ok(self) } pub fn java_generate_equals_and_hash(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(20, value)?; self.java_generate_equals_and_hash_written = true; Ok(self) } pub fn java_string_check_utf8(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(27, value)?; self.java_string_check_utf8_written = true; Ok(self) } pub fn optimize_for(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(9, value)?; self.optimize_for_written = true; Ok(self) } pub fn go_package(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(11, value)?; self.go_package_written = true; Ok(self) } pub fn cc_generic_services(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(16, value)?; self.cc_generic_services_written = true; Ok(self) } pub fn java_generic_services(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(17, value)?; self.java_generic_services_written = true; Ok(self) } pub fn py_generic_services(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(18, value)?; self.py_generic_services_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(23, value)?; self.deprecated_written = true; Ok(self) } pub fn cc_enable_arenas(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(31, value)?; self.cc_enable_arenas_written = true; Ok(self) } pub fn objc_class_prefix(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(36, value)?; self.objc_class_prefix_written = true; Ok(self) } pub fn csharp_namespace(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(37, value)?; self.csharp_namespace_written = true; Ok(self) } pub fn swift_prefix(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(39, value)?; self.swift_prefix_written = true; Ok(self) } pub fn php_class_prefix(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(40, value)?; self.php_class_prefix_written = true; Ok(self) } pub fn php_namespace(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(41, value)?; self.php_namespace_written = true; Ok(self) } pub fn php_metadata_namespace(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(44, value)?; self.php_metadata_namespace_written = true; Ok(self) } pub fn ruby_package(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(45, value)?; self.ruby_package_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(50, value)?; self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } pub fn with(mut self, msg: &FileOptions<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.java_package_written, 8 => self.java_outer_classname_written, 10 => self.java_multiple_files_written, 20 => self.java_generate_equals_and_hash_written, 27 => self.java_string_check_utf8_written, 9 => self.optimize_for_written, 11 => self.go_package_written, 16 => self.cc_generic_services_written, 17 => self.java_generic_services_written, 18 => self.py_generic_services_written, 23 => self.deprecated_written, 31 => self.cc_enable_arenas_written, 36 => self.objc_class_prefix_written, 37 => self.csharp_namespace_written, 39 => self.swift_prefix_written, 40 => self.php_class_prefix_written, 41 => self.php_namespace_written, 44 => self.php_metadata_namespace_written, 45 => self.ruby_package_written, 50 => self.features_written, 999 => self.uninterpreted_option_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedFileOptions { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedFileOptions { type Reader<'a> = FileOptions<'a>; fn reader(&self) -> FileOptions<'_> { FileOptions::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedFileOptions { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedFileOptions { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod file_options { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum OptimizeMode { SPEED = 1, CODESIZE = 2, LITERUNTIME = 3, Unknown = 0, } impl OptimizeMode { pub fn from_i32(value: i32) -> Self { match value { 1 => OptimizeMode::SPEED, 2 => OptimizeMode::CODESIZE, 3 => OptimizeMode::LITERUNTIME, _ => OptimizeMode::Unknown, } } } } pub struct MessageOptions<'a> { accessor: crate::runtime::ProtoAccessor<'a>, message_set_wire_format_offset: Option, no_standard_descriptor_accessor_offset: Option, deprecated_offset: Option, map_entry_offset: Option, deprecated_legacy_json_field_conflicts_offset: Option, features_offset: Option, uninterpreted_option_start: Option, uninterpreted_option_end: Option, } impl<'a> MessageOptions<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut message_set_wire_format_offset = None; let mut no_standard_descriptor_accessor_offset = None; let mut deprecated_offset = None; let mut map_entry_offset = None; let mut deprecated_legacy_json_field_conflicts_offset = None; let mut features_offset = None; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { message_set_wire_format_offset = Some(offset); } if tag.field_number == 2 { no_standard_descriptor_accessor_offset = Some(offset); } if tag.field_number == 3 { deprecated_offset = Some(offset); } if tag.field_number == 7 { map_entry_offset = Some(offset); } if tag.field_number == 11 { deprecated_legacy_json_field_conflicts_offset = Some(offset); } if tag.field_number == 12 { features_offset = Some(offset); } if tag.field_number == 999 { if uninterpreted_option_start.is_none() { uninterpreted_option_start = Some(offset); } uninterpreted_option_end = Some(offset); } } Ok(Self { accessor, message_set_wire_format_offset, no_standard_descriptor_accessor_offset, deprecated_offset, map_entry_offset, deprecated_legacy_json_field_conflicts_offset, features_offset, uninterpreted_option_start, uninterpreted_option_end, }) } pub fn message_set_wire_format(&self) -> crate::runtime::Result { let offset = self.message_set_wire_format_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn message_set_wire_format_or_default(&self) -> crate::runtime::Result { self.message_set_wire_format().or(Ok(false)) } pub fn has_message_set_wire_format(&self) -> bool { self.message_set_wire_format_offset.is_some() } pub fn no_standard_descriptor_accessor(&self) -> crate::runtime::Result { let offset = self.no_standard_descriptor_accessor_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn no_standard_descriptor_accessor_or_default(&self) -> crate::runtime::Result { self.no_standard_descriptor_accessor().or(Ok(false)) } pub fn has_no_standard_descriptor_accessor(&self) -> bool { self.no_standard_descriptor_accessor_offset.is_some() } pub fn deprecated(&self) -> crate::runtime::Result { let offset = self.deprecated_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecated_or_default(&self) -> crate::runtime::Result { self.deprecated().or(Ok(false)) } pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } pub fn map_entry(&self) -> crate::runtime::Result { let offset = self.map_entry_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn map_entry_or_default(&self) -> crate::runtime::Result { self.map_entry().or(Ok(false)) } pub fn has_map_entry(&self) -> bool { self.map_entry_offset.is_some() } pub fn deprecated_legacy_json_field_conflicts(&self) -> crate::runtime::Result { let offset = self.deprecated_legacy_json_field_conflicts_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecated_legacy_json_field_conflicts_or_default(&self) -> crate::runtime::Result { self.deprecated_legacy_json_field_conflicts().or(Ok(false)) } pub fn has_deprecated_legacy_json_field_conflicts(&self) -> bool { self.deprecated_legacy_json_field_conflicts_offset.is_some() } pub fn features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.features().or(Ok(&[])) } pub fn has_features(&self) -> bool { self.features_offset.is_some() } pub fn uninterpreted_option(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.uninterpreted_option_start, self.uninterpreted_option_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(999, start, end), _ => self.accessor.iter_repeated(999), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct MessageOptionsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, message_set_wire_format_written: bool, no_standard_descriptor_accessor_written: bool, deprecated_written: bool, map_entry_written: bool, deprecated_legacy_json_field_conflicts_written: bool, features_written: bool, uninterpreted_option_written: bool, } impl<'b> MessageOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> MessageOptionsBuilder<'_> { MessageOptionsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), message_set_wire_format_written: false, no_standard_descriptor_accessor_written: false, deprecated_written: false, map_entry_written: false, deprecated_legacy_json_field_conflicts_written: false, features_written: false, uninterpreted_option_written: false, } } pub fn message_set_wire_format(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(1, value)?; self.message_set_wire_format_written = true; Ok(self) } pub fn no_standard_descriptor_accessor(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(2, value)?; self.no_standard_descriptor_accessor_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(3, value)?; self.deprecated_written = true; Ok(self) } pub fn map_entry(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(7, value)?; self.map_entry_written = true; Ok(self) } pub fn deprecated_legacy_json_field_conflicts(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(11, value)?; self.deprecated_legacy_json_field_conflicts_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(12, value)?; self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } pub fn with(mut self, msg: &MessageOptions<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.message_set_wire_format_written, 2 => self.no_standard_descriptor_accessor_written, 3 => self.deprecated_written, 7 => self.map_entry_written, 11 => self.deprecated_legacy_json_field_conflicts_written, 12 => self.features_written, 999 => self.uninterpreted_option_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedMessageOptions { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedMessageOptions { type Reader<'a> = MessageOptions<'a>; fn reader(&self) -> MessageOptions<'_> { MessageOptions::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedMessageOptions { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedMessageOptions { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct FieldOptions<'a> { accessor: crate::runtime::ProtoAccessor<'a>, ctype_offset: Option, packed_offset: Option, jstype_offset: Option, lazy_offset: Option, unverified_lazy_offset: Option, deprecated_offset: Option, weak_offset: Option, debug_redact_offset: Option, retention_offset: Option, targets_start: Option, targets_end: Option, edition_defaults_start: Option, edition_defaults_end: Option, features_offset: Option, feature_support_offset: Option, uninterpreted_option_start: Option, uninterpreted_option_end: Option, } impl<'a> FieldOptions<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut ctype_offset = None; let mut packed_offset = None; let mut jstype_offset = None; let mut lazy_offset = None; let mut unverified_lazy_offset = None; let mut deprecated_offset = None; let mut weak_offset = None; let mut debug_redact_offset = None; let mut retention_offset = None; let mut targets_start = None; let mut targets_end = None; let mut edition_defaults_start = None; let mut edition_defaults_end = None; let mut features_offset = None; let mut feature_support_offset = None; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { ctype_offset = Some(offset); } if tag.field_number == 2 { packed_offset = Some(offset); } if tag.field_number == 6 { jstype_offset = Some(offset); } if tag.field_number == 5 { lazy_offset = Some(offset); } if tag.field_number == 15 { unverified_lazy_offset = Some(offset); } if tag.field_number == 3 { deprecated_offset = Some(offset); } if tag.field_number == 10 { weak_offset = Some(offset); } if tag.field_number == 16 { debug_redact_offset = Some(offset); } if tag.field_number == 17 { retention_offset = Some(offset); } if tag.field_number == 19 { if targets_start.is_none() { targets_start = Some(offset); } targets_end = Some(offset); } if tag.field_number == 20 { if edition_defaults_start.is_none() { edition_defaults_start = Some(offset); } edition_defaults_end = Some(offset); } if tag.field_number == 21 { features_offset = Some(offset); } if tag.field_number == 22 { feature_support_offset = Some(offset); } if tag.field_number == 999 { if uninterpreted_option_start.is_none() { uninterpreted_option_start = Some(offset); } uninterpreted_option_end = Some(offset); } } Ok(Self { accessor, ctype_offset, packed_offset, jstype_offset, lazy_offset, unverified_lazy_offset, deprecated_offset, weak_offset, debug_redact_offset, retention_offset, targets_start, targets_end, edition_defaults_start, edition_defaults_end, features_offset, feature_support_offset, uninterpreted_option_start, uninterpreted_option_end, }) } pub fn ctype(&self) -> crate::runtime::Result { let offset = self.ctype_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn ctype_or_default(&self) -> crate::runtime::Result { self.ctype().or(Ok(0)) } pub fn has_ctype(&self) -> bool { self.ctype_offset.is_some() } pub fn packed(&self) -> crate::runtime::Result { let offset = self.packed_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn packed_or_default(&self) -> crate::runtime::Result { self.packed().or(Ok(false)) } pub fn has_packed(&self) -> bool { self.packed_offset.is_some() } pub fn jstype(&self) -> crate::runtime::Result { let offset = self.jstype_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn jstype_or_default(&self) -> crate::runtime::Result { self.jstype().or(Ok(0)) } pub fn has_jstype(&self) -> bool { self.jstype_offset.is_some() } pub fn lazy(&self) -> crate::runtime::Result { let offset = self.lazy_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn lazy_or_default(&self) -> crate::runtime::Result { self.lazy().or(Ok(false)) } pub fn has_lazy(&self) -> bool { self.lazy_offset.is_some() } pub fn unverified_lazy(&self) -> crate::runtime::Result { let offset = self.unverified_lazy_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn unverified_lazy_or_default(&self) -> crate::runtime::Result { self.unverified_lazy().or(Ok(false)) } pub fn has_unverified_lazy(&self) -> bool { self.unverified_lazy_offset.is_some() } pub fn deprecated(&self) -> crate::runtime::Result { let offset = self.deprecated_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecated_or_default(&self) -> crate::runtime::Result { self.deprecated().or(Ok(false)) } pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } pub fn weak(&self) -> crate::runtime::Result { let offset = self.weak_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn weak_or_default(&self) -> crate::runtime::Result { self.weak().or(Ok(false)) } pub fn has_weak(&self) -> bool { self.weak_offset.is_some() } pub fn debug_redact(&self) -> crate::runtime::Result { let offset = self.debug_redact_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn debug_redact_or_default(&self) -> crate::runtime::Result { self.debug_redact().or(Ok(false)) } pub fn has_debug_redact(&self) -> bool { self.debug_redact_offset.is_some() } pub fn retention(&self) -> crate::runtime::Result { let offset = self.retention_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn retention_or_default(&self) -> crate::runtime::Result { self.retention().or(Ok(0)) } pub fn has_retention(&self) -> bool { self.retention_offset.is_some() } pub fn targets(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.targets_start, self.targets_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(19, start, end), _ => self.accessor.iter_repeated(19), } } pub fn edition_defaults(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.edition_defaults_start, self.edition_defaults_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(20, start, end), _ => self.accessor.iter_repeated(20), } } pub fn features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.features().or(Ok(&[])) } pub fn has_features(&self) -> bool { self.features_offset.is_some() } pub fn feature_support(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.feature_support_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn feature_support_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.feature_support().or(Ok(&[])) } pub fn has_feature_support(&self) -> bool { self.feature_support_offset.is_some() } pub fn uninterpreted_option(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.uninterpreted_option_start, self.uninterpreted_option_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(999, start, end), _ => self.accessor.iter_repeated(999), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FieldOptionsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, ctype_written: bool, packed_written: bool, jstype_written: bool, lazy_written: bool, unverified_lazy_written: bool, deprecated_written: bool, weak_written: bool, debug_redact_written: bool, retention_written: bool, targets_written: bool, edition_defaults_written: bool, features_written: bool, feature_support_written: bool, uninterpreted_option_written: bool, } impl<'b> FieldOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FieldOptionsBuilder<'_> { FieldOptionsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), ctype_written: false, packed_written: false, jstype_written: false, lazy_written: false, unverified_lazy_written: false, deprecated_written: false, weak_written: false, debug_redact_written: false, retention_written: false, targets_written: false, edition_defaults_written: false, features_written: false, feature_support_written: false, uninterpreted_option_written: false, } } pub fn ctype(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(1, value)?; self.ctype_written = true; Ok(self) } pub fn packed(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(2, value)?; self.packed_written = true; Ok(self) } pub fn jstype(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(6, value)?; self.jstype_written = true; Ok(self) } pub fn lazy(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(5, value)?; self.lazy_written = true; Ok(self) } pub fn unverified_lazy(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(15, value)?; self.unverified_lazy_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(3, value)?; self.deprecated_written = true; Ok(self) } pub fn weak(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(10, value)?; self.weak_written = true; Ok(self) } pub fn debug_redact(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(16, value)?; self.debug_redact_written = true; Ok(self) } pub fn retention(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(17, value)?; self.retention_written = true; Ok(self) } pub fn targets(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(19, value)?; self.targets_written = true; Ok(self) } pub fn edition_defaults(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(20, value)?; self.edition_defaults_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(21, value)?; self.features_written = true; Ok(self) } pub fn feature_support(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(22, value)?; self.feature_support_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } pub fn with(mut self, msg: &FieldOptions<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.ctype_written, 2 => self.packed_written, 6 => self.jstype_written, 5 => self.lazy_written, 15 => self.unverified_lazy_written, 3 => self.deprecated_written, 10 => self.weak_written, 16 => self.debug_redact_written, 17 => self.retention_written, 19 => self.targets_written, 20 => self.edition_defaults_written, 21 => self.features_written, 22 => self.feature_support_written, 999 => self.uninterpreted_option_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedFieldOptions { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedFieldOptions { type Reader<'a> = FieldOptions<'a>; fn reader(&self) -> FieldOptions<'_> { FieldOptions::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedFieldOptions { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedFieldOptions { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod field_options { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum CType { STRING = 0, CORD = 1, STRINGPIECE = 2, } impl CType { pub fn from_i32(value: i32) -> Self { match value { 0 => CType::STRING, 1 => CType::CORD, 2 => CType::STRINGPIECE, _ => CType::STRING, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum JSType { JSNORMAL = 0, JSSTRING = 1, JSNUMBER = 2, } impl JSType { pub fn from_i32(value: i32) -> Self { match value { 0 => JSType::JSNORMAL, 1 => JSType::JSSTRING, 2 => JSType::JSNUMBER, _ => JSType::JSNORMAL, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum OptionRetention { RETENTIONUNKNOWN = 0, RETENTIONRUNTIME = 1, RETENTIONSOURCE = 2, } impl OptionRetention { pub fn from_i32(value: i32) -> Self { match value { 0 => OptionRetention::RETENTIONUNKNOWN, 1 => OptionRetention::RETENTIONRUNTIME, 2 => OptionRetention::RETENTIONSOURCE, _ => OptionRetention::RETENTIONUNKNOWN, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum OptionTargetType { TARGETTYPEUNKNOWN = 0, TARGETTYPEFILE = 1, TARGETTYPEEXTENSIONRANGE = 2, TARGETTYPEMESSAGE = 3, TARGETTYPEFIELD = 4, TARGETTYPEONEOF = 5, TARGETTYPEENUM = 6, TARGETTYPEENUMENTRY = 7, TARGETTYPESERVICE = 8, TARGETTYPEMETHOD = 9, } impl OptionTargetType { pub fn from_i32(value: i32) -> Self { match value { 0 => OptionTargetType::TARGETTYPEUNKNOWN, 1 => OptionTargetType::TARGETTYPEFILE, 2 => OptionTargetType::TARGETTYPEEXTENSIONRANGE, 3 => OptionTargetType::TARGETTYPEMESSAGE, 4 => OptionTargetType::TARGETTYPEFIELD, 5 => OptionTargetType::TARGETTYPEONEOF, 6 => OptionTargetType::TARGETTYPEENUM, 7 => OptionTargetType::TARGETTYPEENUMENTRY, 8 => OptionTargetType::TARGETTYPESERVICE, 9 => OptionTargetType::TARGETTYPEMETHOD, _ => OptionTargetType::TARGETTYPEUNKNOWN, } } } pub struct EditionDefault<'a> { accessor: crate::runtime::ProtoAccessor<'a>, edition_offset: Option, value_offset: Option, } impl<'a> EditionDefault<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut edition_offset = None; let mut value_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 3 { edition_offset = Some(offset); } if tag.field_number == 2 { value_offset = Some(offset); } } Ok(Self { accessor, edition_offset, value_offset, }) } pub fn edition(&self) -> crate::runtime::Result { let offset = self.edition_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn edition_or_default(&self) -> crate::runtime::Result { self.edition().or(Ok(0)) } pub fn has_edition(&self) -> bool { self.edition_offset.is_some() } pub fn value(&self) -> crate::runtime::Result<&'a str> { let offset = self.value_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn value_or_default(&self) -> crate::runtime::Result<&'a str> { self.value().or(Ok("")) } pub fn has_value(&self) -> bool { self.value_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EditionDefaultBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, edition_written: bool, value_written: bool, } impl<'b> EditionDefaultBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EditionDefaultBuilder<'_> { EditionDefaultBuilder { builder: crate::runtime::ProtoBuilder::new(buf), edition_written: false, value_written: false, } } pub fn edition(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(3, value)?; self.edition_written = true; Ok(self) } pub fn value(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(2, value)?; self.value_written = true; Ok(self) } pub fn with(mut self, msg: &EditionDefault<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 3 => self.edition_written, 2 => self.value_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedEditionDefault { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedEditionDefault { type Reader<'a> = EditionDefault<'a>; fn reader(&self) -> EditionDefault<'_> { EditionDefault::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedEditionDefault { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedEditionDefault { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct FeatureSupport<'a> { accessor: crate::runtime::ProtoAccessor<'a>, edition_introduced_offset: Option, edition_deprecated_offset: Option, deprecation_warning_offset: Option, edition_removed_offset: Option, removal_error_offset: Option, } impl<'a> FeatureSupport<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut edition_introduced_offset = None; let mut edition_deprecated_offset = None; let mut deprecation_warning_offset = None; let mut edition_removed_offset = None; let mut removal_error_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { edition_introduced_offset = Some(offset); } if tag.field_number == 2 { edition_deprecated_offset = Some(offset); } if tag.field_number == 3 { deprecation_warning_offset = Some(offset); } if tag.field_number == 4 { edition_removed_offset = Some(offset); } if tag.field_number == 5 { removal_error_offset = Some(offset); } } Ok(Self { accessor, edition_introduced_offset, edition_deprecated_offset, deprecation_warning_offset, edition_removed_offset, removal_error_offset, }) } pub fn edition_introduced(&self) -> crate::runtime::Result { let offset = self.edition_introduced_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn edition_introduced_or_default(&self) -> crate::runtime::Result { self.edition_introduced().or(Ok(0)) } pub fn has_edition_introduced(&self) -> bool { self.edition_introduced_offset.is_some() } pub fn edition_deprecated(&self) -> crate::runtime::Result { let offset = self.edition_deprecated_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn edition_deprecated_or_default(&self) -> crate::runtime::Result { self.edition_deprecated().or(Ok(0)) } pub fn has_edition_deprecated(&self) -> bool { self.edition_deprecated_offset.is_some() } pub fn deprecation_warning(&self) -> crate::runtime::Result<&'a str> { let offset = self.deprecation_warning_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecation_warning_or_default(&self) -> crate::runtime::Result<&'a str> { self.deprecation_warning().or(Ok("")) } pub fn has_deprecation_warning(&self) -> bool { self.deprecation_warning_offset.is_some() } pub fn edition_removed(&self) -> crate::runtime::Result { let offset = self.edition_removed_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn edition_removed_or_default(&self) -> crate::runtime::Result { self.edition_removed().or(Ok(0)) } pub fn has_edition_removed(&self) -> bool { self.edition_removed_offset.is_some() } pub fn removal_error(&self) -> crate::runtime::Result<&'a str> { let offset = self.removal_error_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn removal_error_or_default(&self) -> crate::runtime::Result<&'a str> { self.removal_error().or(Ok("")) } pub fn has_removal_error(&self) -> bool { self.removal_error_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FeatureSupportBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, edition_introduced_written: bool, edition_deprecated_written: bool, deprecation_warning_written: bool, edition_removed_written: bool, removal_error_written: bool, } impl<'b> FeatureSupportBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSupportBuilder<'_> { FeatureSupportBuilder { builder: crate::runtime::ProtoBuilder::new(buf), edition_introduced_written: false, edition_deprecated_written: false, deprecation_warning_written: false, edition_removed_written: false, removal_error_written: false, } } pub fn edition_introduced(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(1, value)?; self.edition_introduced_written = true; Ok(self) } pub fn edition_deprecated(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(2, value)?; self.edition_deprecated_written = true; Ok(self) } pub fn deprecation_warning(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(3, value)?; self.deprecation_warning_written = true; Ok(self) } pub fn edition_removed(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(4, value)?; self.edition_removed_written = true; Ok(self) } pub fn removal_error(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(5, value)?; self.removal_error_written = true; Ok(self) } pub fn with(mut self, msg: &FeatureSupport<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.edition_introduced_written, 2 => self.edition_deprecated_written, 3 => self.deprecation_warning_written, 4 => self.edition_removed_written, 5 => self.removal_error_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedFeatureSupport { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedFeatureSupport { type Reader<'a> = FeatureSupport<'a>; fn reader(&self) -> FeatureSupport<'_> { FeatureSupport::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedFeatureSupport { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedFeatureSupport { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } } pub struct OneofOptions<'a> { accessor: crate::runtime::ProtoAccessor<'a>, features_offset: Option, uninterpreted_option_start: Option, uninterpreted_option_end: Option, } impl<'a> OneofOptions<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut features_offset = None; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { features_offset = Some(offset); } if tag.field_number == 999 { if uninterpreted_option_start.is_none() { uninterpreted_option_start = Some(offset); } uninterpreted_option_end = Some(offset); } } Ok(Self { accessor, features_offset, uninterpreted_option_start, uninterpreted_option_end, }) } pub fn features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.features().or(Ok(&[])) } pub fn has_features(&self) -> bool { self.features_offset.is_some() } pub fn uninterpreted_option(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.uninterpreted_option_start, self.uninterpreted_option_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(999, start, end), _ => self.accessor.iter_repeated(999), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct OneofOptionsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, features_written: bool, uninterpreted_option_written: bool, } impl<'b> OneofOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> OneofOptionsBuilder<'_> { OneofOptionsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), features_written: false, uninterpreted_option_written: false, } } pub fn features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(1, value)?; self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } pub fn with(mut self, msg: &OneofOptions<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.features_written, 999 => self.uninterpreted_option_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedOneofOptions { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedOneofOptions { type Reader<'a> = OneofOptions<'a>; fn reader(&self) -> OneofOptions<'_> { OneofOptions::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedOneofOptions { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedOneofOptions { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct EnumOptions<'a> { accessor: crate::runtime::ProtoAccessor<'a>, allow_alias_offset: Option, deprecated_offset: Option, deprecated_legacy_json_field_conflicts_offset: Option, features_offset: Option, uninterpreted_option_start: Option, uninterpreted_option_end: Option, } impl<'a> EnumOptions<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut allow_alias_offset = None; let mut deprecated_offset = None; let mut deprecated_legacy_json_field_conflicts_offset = None; let mut features_offset = None; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 2 { allow_alias_offset = Some(offset); } if tag.field_number == 3 { deprecated_offset = Some(offset); } if tag.field_number == 6 { deprecated_legacy_json_field_conflicts_offset = Some(offset); } if tag.field_number == 7 { features_offset = Some(offset); } if tag.field_number == 999 { if uninterpreted_option_start.is_none() { uninterpreted_option_start = Some(offset); } uninterpreted_option_end = Some(offset); } } Ok(Self { accessor, allow_alias_offset, deprecated_offset, deprecated_legacy_json_field_conflicts_offset, features_offset, uninterpreted_option_start, uninterpreted_option_end, }) } pub fn allow_alias(&self) -> crate::runtime::Result { let offset = self.allow_alias_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn allow_alias_or_default(&self) -> crate::runtime::Result { self.allow_alias().or(Ok(false)) } pub fn has_allow_alias(&self) -> bool { self.allow_alias_offset.is_some() } pub fn deprecated(&self) -> crate::runtime::Result { let offset = self.deprecated_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecated_or_default(&self) -> crate::runtime::Result { self.deprecated().or(Ok(false)) } pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } pub fn deprecated_legacy_json_field_conflicts(&self) -> crate::runtime::Result { let offset = self.deprecated_legacy_json_field_conflicts_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecated_legacy_json_field_conflicts_or_default(&self) -> crate::runtime::Result { self.deprecated_legacy_json_field_conflicts().or(Ok(false)) } pub fn has_deprecated_legacy_json_field_conflicts(&self) -> bool { self.deprecated_legacy_json_field_conflicts_offset.is_some() } pub fn features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.features().or(Ok(&[])) } pub fn has_features(&self) -> bool { self.features_offset.is_some() } pub fn uninterpreted_option(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.uninterpreted_option_start, self.uninterpreted_option_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(999, start, end), _ => self.accessor.iter_repeated(999), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumOptionsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, allow_alias_written: bool, deprecated_written: bool, deprecated_legacy_json_field_conflicts_written: bool, features_written: bool, uninterpreted_option_written: bool, } impl<'b> EnumOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumOptionsBuilder<'_> { EnumOptionsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), allow_alias_written: false, deprecated_written: false, deprecated_legacy_json_field_conflicts_written: false, features_written: false, uninterpreted_option_written: false, } } pub fn allow_alias(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(2, value)?; self.allow_alias_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(3, value)?; self.deprecated_written = true; Ok(self) } pub fn deprecated_legacy_json_field_conflicts(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(6, value)?; self.deprecated_legacy_json_field_conflicts_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(7, value)?; self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } pub fn with(mut self, msg: &EnumOptions<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 2 => self.allow_alias_written, 3 => self.deprecated_written, 6 => self.deprecated_legacy_json_field_conflicts_written, 7 => self.features_written, 999 => self.uninterpreted_option_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedEnumOptions { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedEnumOptions { type Reader<'a> = EnumOptions<'a>; fn reader(&self) -> EnumOptions<'_> { EnumOptions::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedEnumOptions { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedEnumOptions { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct EnumValueOptions<'a> { accessor: crate::runtime::ProtoAccessor<'a>, deprecated_offset: Option, features_offset: Option, debug_redact_offset: Option, feature_support_offset: Option, uninterpreted_option_start: Option, uninterpreted_option_end: Option, } impl<'a> EnumValueOptions<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut deprecated_offset = None; let mut features_offset = None; let mut debug_redact_offset = None; let mut feature_support_offset = None; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { deprecated_offset = Some(offset); } if tag.field_number == 2 { features_offset = Some(offset); } if tag.field_number == 3 { debug_redact_offset = Some(offset); } if tag.field_number == 4 { feature_support_offset = Some(offset); } if tag.field_number == 999 { if uninterpreted_option_start.is_none() { uninterpreted_option_start = Some(offset); } uninterpreted_option_end = Some(offset); } } Ok(Self { accessor, deprecated_offset, features_offset, debug_redact_offset, feature_support_offset, uninterpreted_option_start, uninterpreted_option_end, }) } pub fn deprecated(&self) -> crate::runtime::Result { let offset = self.deprecated_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecated_or_default(&self) -> crate::runtime::Result { self.deprecated().or(Ok(false)) } pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } pub fn features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.features().or(Ok(&[])) } pub fn has_features(&self) -> bool { self.features_offset.is_some() } pub fn debug_redact(&self) -> crate::runtime::Result { let offset = self.debug_redact_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn debug_redact_or_default(&self) -> crate::runtime::Result { self.debug_redact().or(Ok(false)) } pub fn has_debug_redact(&self) -> bool { self.debug_redact_offset.is_some() } pub fn feature_support(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.feature_support_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn feature_support_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.feature_support().or(Ok(&[])) } pub fn has_feature_support(&self) -> bool { self.feature_support_offset.is_some() } pub fn uninterpreted_option(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.uninterpreted_option_start, self.uninterpreted_option_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(999, start, end), _ => self.accessor.iter_repeated(999), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumValueOptionsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, deprecated_written: bool, features_written: bool, debug_redact_written: bool, feature_support_written: bool, uninterpreted_option_written: bool, } impl<'b> EnumValueOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumValueOptionsBuilder<'_> { EnumValueOptionsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), deprecated_written: false, features_written: false, debug_redact_written: false, feature_support_written: false, uninterpreted_option_written: false, } } pub fn deprecated(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(1, value)?; self.deprecated_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(2, value)?; self.features_written = true; Ok(self) } pub fn debug_redact(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(3, value)?; self.debug_redact_written = true; Ok(self) } pub fn feature_support(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(4, value)?; self.feature_support_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } pub fn with(mut self, msg: &EnumValueOptions<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.deprecated_written, 2 => self.features_written, 3 => self.debug_redact_written, 4 => self.feature_support_written, 999 => self.uninterpreted_option_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedEnumValueOptions { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedEnumValueOptions { type Reader<'a> = EnumValueOptions<'a>; fn reader(&self) -> EnumValueOptions<'_> { EnumValueOptions::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedEnumValueOptions { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedEnumValueOptions { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct ServiceOptions<'a> { accessor: crate::runtime::ProtoAccessor<'a>, features_offset: Option, deprecated_offset: Option, uninterpreted_option_start: Option, uninterpreted_option_end: Option, } impl<'a> ServiceOptions<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut features_offset = None; let mut deprecated_offset = None; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 34 { features_offset = Some(offset); } if tag.field_number == 33 { deprecated_offset = Some(offset); } if tag.field_number == 999 { if uninterpreted_option_start.is_none() { uninterpreted_option_start = Some(offset); } uninterpreted_option_end = Some(offset); } } Ok(Self { accessor, features_offset, deprecated_offset, uninterpreted_option_start, uninterpreted_option_end, }) } pub fn features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.features().or(Ok(&[])) } pub fn has_features(&self) -> bool { self.features_offset.is_some() } pub fn deprecated(&self) -> crate::runtime::Result { let offset = self.deprecated_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecated_or_default(&self) -> crate::runtime::Result { self.deprecated().or(Ok(false)) } pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } pub fn uninterpreted_option(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.uninterpreted_option_start, self.uninterpreted_option_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(999, start, end), _ => self.accessor.iter_repeated(999), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ServiceOptionsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, features_written: bool, deprecated_written: bool, uninterpreted_option_written: bool, } impl<'b> ServiceOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ServiceOptionsBuilder<'_> { ServiceOptionsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), features_written: false, deprecated_written: false, uninterpreted_option_written: false, } } pub fn features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(34, value)?; self.features_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(33, value)?; self.deprecated_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } pub fn with(mut self, msg: &ServiceOptions<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 34 => self.features_written, 33 => self.deprecated_written, 999 => self.uninterpreted_option_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedServiceOptions { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedServiceOptions { type Reader<'a> = ServiceOptions<'a>; fn reader(&self) -> ServiceOptions<'_> { ServiceOptions::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedServiceOptions { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedServiceOptions { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub struct MethodOptions<'a> { accessor: crate::runtime::ProtoAccessor<'a>, deprecated_offset: Option, idempotency_level_offset: Option, features_offset: Option, uninterpreted_option_start: Option, uninterpreted_option_end: Option, } impl<'a> MethodOptions<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut deprecated_offset = None; let mut idempotency_level_offset = None; let mut features_offset = None; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 33 { deprecated_offset = Some(offset); } if tag.field_number == 34 { idempotency_level_offset = Some(offset); } if tag.field_number == 35 { features_offset = Some(offset); } if tag.field_number == 999 { if uninterpreted_option_start.is_none() { uninterpreted_option_start = Some(offset); } uninterpreted_option_end = Some(offset); } } Ok(Self { accessor, deprecated_offset, idempotency_level_offset, features_offset, uninterpreted_option_start, uninterpreted_option_end, }) } pub fn deprecated(&self) -> crate::runtime::Result { let offset = self.deprecated_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn deprecated_or_default(&self) -> crate::runtime::Result { self.deprecated().or(Ok(false)) } pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } pub fn idempotency_level(&self) -> crate::runtime::Result { let offset = self.idempotency_level_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn idempotency_level_or_default(&self) -> crate::runtime::Result { self.idempotency_level().or(Ok(0)) } pub fn has_idempotency_level(&self) -> bool { self.idempotency_level_offset.is_some() } pub fn features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.features().or(Ok(&[])) } pub fn has_features(&self) -> bool { self.features_offset.is_some() } pub fn uninterpreted_option(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.uninterpreted_option_start, self.uninterpreted_option_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(999, start, end), _ => self.accessor.iter_repeated(999), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct MethodOptionsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, deprecated_written: bool, idempotency_level_written: bool, features_written: bool, uninterpreted_option_written: bool, } impl<'b> MethodOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> MethodOptionsBuilder<'_> { MethodOptionsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), deprecated_written: false, idempotency_level_written: false, features_written: false, uninterpreted_option_written: false, } } pub fn deprecated(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(33, value)?; self.deprecated_written = true; Ok(self) } pub fn idempotency_level(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(34, value)?; self.idempotency_level_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(35, value)?; self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } pub fn with(mut self, msg: &MethodOptions<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 33 => self.deprecated_written, 34 => self.idempotency_level_written, 35 => self.features_written, 999 => self.uninterpreted_option_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedMethodOptions { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedMethodOptions { type Reader<'a> = MethodOptions<'a>; fn reader(&self) -> MethodOptions<'_> { MethodOptions::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedMethodOptions { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedMethodOptions { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod method_options { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum IdempotencyLevel { IDEMPOTENCYUNKNOWN = 0, NOSIDEEFFECTS = 1, IDEMPOTENT = 2, } impl IdempotencyLevel { pub fn from_i32(value: i32) -> Self { match value { 0 => IdempotencyLevel::IDEMPOTENCYUNKNOWN, 1 => IdempotencyLevel::NOSIDEEFFECTS, 2 => IdempotencyLevel::IDEMPOTENT, _ => IdempotencyLevel::IDEMPOTENCYUNKNOWN, } } } } pub struct UninterpretedOption<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_start: Option, name_end: Option, identifier_value_offset: Option, positive_int_value_offset: Option, negative_int_value_offset: Option, double_value_offset: Option, string_value_offset: Option, aggregate_value_offset: Option, } impl<'a> UninterpretedOption<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_start = None; let mut name_end = None; let mut identifier_value_offset = None; let mut positive_int_value_offset = None; let mut negative_int_value_offset = None; let mut double_value_offset = None; let mut string_value_offset = None; let mut aggregate_value_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 2 { if name_start.is_none() { name_start = Some(offset); } name_end = Some(offset); } if tag.field_number == 3 { identifier_value_offset = Some(offset); } if tag.field_number == 4 { positive_int_value_offset = Some(offset); } if tag.field_number == 5 { negative_int_value_offset = Some(offset); } if tag.field_number == 6 { double_value_offset = Some(offset); } if tag.field_number == 7 { string_value_offset = Some(offset); } if tag.field_number == 8 { aggregate_value_offset = Some(offset); } } Ok(Self { accessor, name_start, name_end, identifier_value_offset, positive_int_value_offset, negative_int_value_offset, double_value_offset, string_value_offset, aggregate_value_offset, }) } pub fn name(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.name_start, self.name_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(2, start, end), _ => self.accessor.iter_repeated(2), } } pub fn identifier_value(&self) -> crate::runtime::Result<&'a str> { let offset = self.identifier_value_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn identifier_value_or_default(&self) -> crate::runtime::Result<&'a str> { self.identifier_value().or(Ok("")) } pub fn has_identifier_value(&self) -> bool { self.identifier_value_offset.is_some() } pub fn positive_int_value(&self) -> crate::runtime::Result { let offset = self.positive_int_value_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn positive_int_value_or_default(&self) -> crate::runtime::Result { self.positive_int_value().or(Ok(0)) } pub fn has_positive_int_value(&self) -> bool { self.positive_int_value_offset.is_some() } pub fn negative_int_value(&self) -> crate::runtime::Result { let offset = self.negative_int_value_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn negative_int_value_or_default(&self) -> crate::runtime::Result { self.negative_int_value().or(Ok(0)) } pub fn has_negative_int_value(&self) -> bool { self.negative_int_value_offset.is_some() } pub fn double_value(&self) -> crate::runtime::Result { let offset = self.double_value_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(f64::from_le_bytes(bytes.try_into().map_err(|_| crate::runtime::RotoError::WireFormatViolation)?)) } pub fn double_value_or_default(&self) -> crate::runtime::Result { self.double_value().or(Ok(0.0)) } pub fn has_double_value(&self) -> bool { self.double_value_offset.is_some() } pub fn string_value(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.string_value_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn string_value_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.string_value().or(Ok(&[])) } pub fn has_string_value(&self) -> bool { self.string_value_offset.is_some() } pub fn aggregate_value(&self) -> crate::runtime::Result<&'a str> { let offset = self.aggregate_value_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn aggregate_value_or_default(&self) -> crate::runtime::Result<&'a str> { self.aggregate_value().or(Ok("")) } pub fn has_aggregate_value(&self) -> bool { self.aggregate_value_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct UninterpretedOptionBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_written: bool, identifier_value_written: bool, positive_int_value_written: bool, negative_int_value_written: bool, double_value_written: bool, string_value_written: bool, aggregate_value_written: bool, } impl<'b> UninterpretedOptionBuilder<'b> { pub fn builder(buf: &mut [u8]) -> UninterpretedOptionBuilder<'_> { UninterpretedOptionBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_written: false, identifier_value_written: false, positive_int_value_written: false, negative_int_value_written: false, double_value_written: false, string_value_written: false, aggregate_value_written: false, } } pub fn name(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(2, value)?; self.name_written = true; Ok(self) } pub fn identifier_value(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(3, value)?; self.identifier_value_written = true; Ok(self) } pub fn positive_int_value(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(4, value)?; self.positive_int_value_written = true; Ok(self) } pub fn negative_int_value(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(5, value)?; self.negative_int_value_written = true; Ok(self) } pub fn double_value(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(6, value)?; self.double_value_written = true; Ok(self) } pub fn string_value(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(7, value)?; self.string_value_written = true; Ok(self) } pub fn aggregate_value(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(8, value)?; self.aggregate_value_written = true; Ok(self) } pub fn with(mut self, msg: &UninterpretedOption<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 2 => self.name_written, 3 => self.identifier_value_written, 4 => self.positive_int_value_written, 5 => self.negative_int_value_written, 6 => self.double_value_written, 7 => self.string_value_written, 8 => self.aggregate_value_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedUninterpretedOption { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedUninterpretedOption { type Reader<'a> = UninterpretedOption<'a>; fn reader(&self) -> UninterpretedOption<'_> { UninterpretedOption::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedUninterpretedOption { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedUninterpretedOption { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod uninterpreted_option { pub struct NamePart<'a> { accessor: crate::runtime::ProtoAccessor<'a>, name_part_offset: Option, is_extension_offset: Option, } impl<'a> NamePart<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut name_part_offset = None; let mut is_extension_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { name_part_offset = Some(offset); } if tag.field_number == 2 { is_extension_offset = Some(offset); } } Ok(Self { accessor, name_part_offset, is_extension_offset, }) } pub fn name_part(&self) -> crate::runtime::Result<&'a str> { let offset = self.name_part_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn name_part_or_default(&self) -> crate::runtime::Result<&'a str> { self.name_part().or(Ok("")) } pub fn has_name_part(&self) -> bool { self.name_part_offset.is_some() } pub fn is_extension(&self) -> crate::runtime::Result { let offset = self.is_extension_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn is_extension_or_default(&self) -> crate::runtime::Result { self.is_extension().or(Ok(false)) } pub fn has_is_extension(&self) -> bool { self.is_extension_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct NamePartBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, name_part_written: bool, is_extension_written: bool, } impl<'b> NamePartBuilder<'b> { pub fn builder(buf: &mut [u8]) -> NamePartBuilder<'_> { NamePartBuilder { builder: crate::runtime::ProtoBuilder::new(buf), name_part_written: false, is_extension_written: false, } } pub fn name_part(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(1, value)?; self.name_part_written = true; Ok(self) } pub fn is_extension(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(2, value)?; self.is_extension_written = true; Ok(self) } pub fn with(mut self, msg: &NamePart<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_part_written, 2 => self.is_extension_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedNamePart { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedNamePart { type Reader<'a> = NamePart<'a>; fn reader(&self) -> NamePart<'_> { NamePart::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedNamePart { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedNamePart { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } } pub struct FeatureSet<'a> { accessor: crate::runtime::ProtoAccessor<'a>, field_presence_offset: Option, enum_type_offset: Option, repeated_field_encoding_offset: Option, utf8_validation_offset: Option, message_encoding_offset: Option, json_format_offset: Option, enforce_naming_style_offset: Option, default_symbol_visibility_offset: Option, enforce_proto_limits_offset: Option, } impl<'a> FeatureSet<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut field_presence_offset = None; let mut enum_type_offset = None; let mut repeated_field_encoding_offset = None; let mut utf8_validation_offset = None; let mut message_encoding_offset = None; let mut json_format_offset = None; let mut enforce_naming_style_offset = None; let mut default_symbol_visibility_offset = None; let mut enforce_proto_limits_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { field_presence_offset = Some(offset); } if tag.field_number == 2 { enum_type_offset = Some(offset); } if tag.field_number == 3 { repeated_field_encoding_offset = Some(offset); } if tag.field_number == 4 { utf8_validation_offset = Some(offset); } if tag.field_number == 5 { message_encoding_offset = Some(offset); } if tag.field_number == 6 { json_format_offset = Some(offset); } if tag.field_number == 7 { enforce_naming_style_offset = Some(offset); } if tag.field_number == 8 { default_symbol_visibility_offset = Some(offset); } if tag.field_number == 9 { enforce_proto_limits_offset = Some(offset); } } Ok(Self { accessor, field_presence_offset, enum_type_offset, repeated_field_encoding_offset, utf8_validation_offset, message_encoding_offset, json_format_offset, enforce_naming_style_offset, default_symbol_visibility_offset, enforce_proto_limits_offset, }) } pub fn field_presence(&self) -> crate::runtime::Result { let offset = self.field_presence_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn field_presence_or_default(&self) -> crate::runtime::Result { self.field_presence().or(Ok(0)) } pub fn has_field_presence(&self) -> bool { self.field_presence_offset.is_some() } pub fn enum_type(&self) -> crate::runtime::Result { let offset = self.enum_type_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn enum_type_or_default(&self) -> crate::runtime::Result { self.enum_type().or(Ok(0)) } pub fn has_enum_type(&self) -> bool { self.enum_type_offset.is_some() } pub fn repeated_field_encoding(&self) -> crate::runtime::Result { let offset = self.repeated_field_encoding_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn repeated_field_encoding_or_default(&self) -> crate::runtime::Result { self.repeated_field_encoding().or(Ok(0)) } pub fn has_repeated_field_encoding(&self) -> bool { self.repeated_field_encoding_offset.is_some() } pub fn utf8_validation(&self) -> crate::runtime::Result { let offset = self.utf8_validation_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn utf8_validation_or_default(&self) -> crate::runtime::Result { self.utf8_validation().or(Ok(0)) } pub fn has_utf8_validation(&self) -> bool { self.utf8_validation_offset.is_some() } pub fn message_encoding(&self) -> crate::runtime::Result { let offset = self.message_encoding_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn message_encoding_or_default(&self) -> crate::runtime::Result { self.message_encoding().or(Ok(0)) } pub fn has_message_encoding(&self) -> bool { self.message_encoding_offset.is_some() } pub fn json_format(&self) -> crate::runtime::Result { let offset = self.json_format_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn json_format_or_default(&self) -> crate::runtime::Result { self.json_format().or(Ok(0)) } pub fn has_json_format(&self) -> bool { self.json_format_offset.is_some() } pub fn enforce_naming_style(&self) -> crate::runtime::Result { let offset = self.enforce_naming_style_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn enforce_naming_style_or_default(&self) -> crate::runtime::Result { self.enforce_naming_style().or(Ok(0)) } pub fn has_enforce_naming_style(&self) -> bool { self.enforce_naming_style_offset.is_some() } pub fn default_symbol_visibility(&self) -> crate::runtime::Result { let offset = self.default_symbol_visibility_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn default_symbol_visibility_or_default(&self) -> crate::runtime::Result { self.default_symbol_visibility().or(Ok(0)) } pub fn has_default_symbol_visibility(&self) -> bool { self.default_symbol_visibility_offset.is_some() } pub fn enforce_proto_limits(&self) -> crate::runtime::Result { let offset = self.enforce_proto_limits_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn enforce_proto_limits_or_default(&self) -> crate::runtime::Result { self.enforce_proto_limits().or(Ok(0)) } pub fn has_enforce_proto_limits(&self) -> bool { self.enforce_proto_limits_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FeatureSetBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, field_presence_written: bool, enum_type_written: bool, repeated_field_encoding_written: bool, utf8_validation_written: bool, message_encoding_written: bool, json_format_written: bool, enforce_naming_style_written: bool, default_symbol_visibility_written: bool, enforce_proto_limits_written: bool, } impl<'b> FeatureSetBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSetBuilder<'_> { FeatureSetBuilder { builder: crate::runtime::ProtoBuilder::new(buf), field_presence_written: false, enum_type_written: false, repeated_field_encoding_written: false, utf8_validation_written: false, message_encoding_written: false, json_format_written: false, enforce_naming_style_written: false, default_symbol_visibility_written: false, enforce_proto_limits_written: false, } } pub fn field_presence(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(1, value)?; self.field_presence_written = true; Ok(self) } pub fn enum_type(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(2, value)?; self.enum_type_written = true; Ok(self) } pub fn repeated_field_encoding(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(3, value)?; self.repeated_field_encoding_written = true; Ok(self) } pub fn utf8_validation(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(4, value)?; self.utf8_validation_written = true; Ok(self) } pub fn message_encoding(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(5, value)?; self.message_encoding_written = true; Ok(self) } pub fn json_format(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(6, value)?; self.json_format_written = true; Ok(self) } pub fn enforce_naming_style(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(7, value)?; self.enforce_naming_style_written = true; Ok(self) } pub fn default_symbol_visibility(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(8, value)?; self.default_symbol_visibility_written = true; Ok(self) } pub fn enforce_proto_limits(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(9, value)?; self.enforce_proto_limits_written = true; Ok(self) } pub fn with(mut self, msg: &FeatureSet<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.field_presence_written, 2 => self.enum_type_written, 3 => self.repeated_field_encoding_written, 4 => self.utf8_validation_written, 5 => self.message_encoding_written, 6 => self.json_format_written, 7 => self.enforce_naming_style_written, 8 => self.default_symbol_visibility_written, 9 => self.enforce_proto_limits_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedFeatureSet { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedFeatureSet { type Reader<'a> = FeatureSet<'a>; fn reader(&self) -> FeatureSet<'_> { FeatureSet::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedFeatureSet { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedFeatureSet { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod feature_set { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum FieldPresence { FIELDPRESENCEUNKNOWN = 0, EXPLICIT = 1, IMPLICIT = 2, LEGACYREQUIRED = 3, } impl FieldPresence { pub fn from_i32(value: i32) -> Self { match value { 0 => FieldPresence::FIELDPRESENCEUNKNOWN, 1 => FieldPresence::EXPLICIT, 2 => FieldPresence::IMPLICIT, 3 => FieldPresence::LEGACYREQUIRED, _ => FieldPresence::FIELDPRESENCEUNKNOWN, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum EnumType { ENUMTYPEUNKNOWN = 0, OPEN = 1, CLOSED = 2, } impl EnumType { pub fn from_i32(value: i32) -> Self { match value { 0 => EnumType::ENUMTYPEUNKNOWN, 1 => EnumType::OPEN, 2 => EnumType::CLOSED, _ => EnumType::ENUMTYPEUNKNOWN, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum RepeatedFieldEncoding { REPEATEDFIELDENCODINGUNKNOWN = 0, PACKED = 1, EXPANDED = 2, } impl RepeatedFieldEncoding { pub fn from_i32(value: i32) -> Self { match value { 0 => RepeatedFieldEncoding::REPEATEDFIELDENCODINGUNKNOWN, 1 => RepeatedFieldEncoding::PACKED, 2 => RepeatedFieldEncoding::EXPANDED, _ => RepeatedFieldEncoding::REPEATEDFIELDENCODINGUNKNOWN, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum Utf8Validation { UTF8VALIDATIONUNKNOWN = 0, VERIFY = 2, NONE = 3, } impl Utf8Validation { pub fn from_i32(value: i32) -> Self { match value { 0 => Utf8Validation::UTF8VALIDATIONUNKNOWN, 2 => Utf8Validation::VERIFY, 3 => Utf8Validation::NONE, _ => Utf8Validation::UTF8VALIDATIONUNKNOWN, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum MessageEncoding { MESSAGEENCODINGUNKNOWN = 0, LENGTHPREFIXED = 1, DELIMITED = 2, } impl MessageEncoding { pub fn from_i32(value: i32) -> Self { match value { 0 => MessageEncoding::MESSAGEENCODINGUNKNOWN, 1 => MessageEncoding::LENGTHPREFIXED, 2 => MessageEncoding::DELIMITED, _ => MessageEncoding::MESSAGEENCODINGUNKNOWN, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum JsonFormat { JSONFORMATUNKNOWN = 0, ALLOW = 1, LEGACYBESTEFFORT = 2, } impl JsonFormat { pub fn from_i32(value: i32) -> Self { match value { 0 => JsonFormat::JSONFORMATUNKNOWN, 1 => JsonFormat::ALLOW, 2 => JsonFormat::LEGACYBESTEFFORT, _ => JsonFormat::JSONFORMATUNKNOWN, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum EnforceNamingStyle { ENFORCENAMINGSTYLEUNKNOWN = 0, STYLE2024 = 1, STYLELEGACY = 2, STYLE2026 = 3, } impl EnforceNamingStyle { pub fn from_i32(value: i32) -> Self { match value { 0 => EnforceNamingStyle::ENFORCENAMINGSTYLEUNKNOWN, 1 => EnforceNamingStyle::STYLE2024, 2 => EnforceNamingStyle::STYLELEGACY, 3 => EnforceNamingStyle::STYLE2026, _ => EnforceNamingStyle::ENFORCENAMINGSTYLEUNKNOWN, } } } pub struct VisibilityFeature<'a> { accessor: crate::runtime::ProtoAccessor<'a>, } impl<'a> VisibilityFeature<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; for item in accessor.fields() { let (offset, tag, _) = item?; } Ok(Self { accessor, }) } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct VisibilityFeatureBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, } impl<'b> VisibilityFeatureBuilder<'b> { pub fn builder(buf: &mut [u8]) -> VisibilityFeatureBuilder<'_> { VisibilityFeatureBuilder { builder: crate::runtime::ProtoBuilder::new(buf), } } pub fn with(mut self, msg: &VisibilityFeature<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedVisibilityFeature { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedVisibilityFeature { type Reader<'a> = VisibilityFeature<'a>; fn reader(&self) -> VisibilityFeature<'_> { VisibilityFeature::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedVisibilityFeature { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedVisibilityFeature { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod visibility_feature { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum DefaultSymbolVisibility { DEFAULTSYMBOLVISIBILITYUNKNOWN = 0, EXPORTALL = 1, EXPORTTOPLEVEL = 2, LOCALALL = 3, STRICT = 4, } impl DefaultSymbolVisibility { pub fn from_i32(value: i32) -> Self { match value { 0 => DefaultSymbolVisibility::DEFAULTSYMBOLVISIBILITYUNKNOWN, 1 => DefaultSymbolVisibility::EXPORTALL, 2 => DefaultSymbolVisibility::EXPORTTOPLEVEL, 3 => DefaultSymbolVisibility::LOCALALL, 4 => DefaultSymbolVisibility::STRICT, _ => DefaultSymbolVisibility::DEFAULTSYMBOLVISIBILITYUNKNOWN, } } } } pub struct ProtoLimitsFeature<'a> { accessor: crate::runtime::ProtoAccessor<'a>, } impl<'a> ProtoLimitsFeature<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; for item in accessor.fields() { let (offset, tag, _) = item?; } Ok(Self { accessor, }) } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ProtoLimitsFeatureBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, } impl<'b> ProtoLimitsFeatureBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ProtoLimitsFeatureBuilder<'_> { ProtoLimitsFeatureBuilder { builder: crate::runtime::ProtoBuilder::new(buf), } } pub fn with(mut self, msg: &ProtoLimitsFeature<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedProtoLimitsFeature { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedProtoLimitsFeature { type Reader<'a> = ProtoLimitsFeature<'a>; fn reader(&self) -> ProtoLimitsFeature<'_> { ProtoLimitsFeature::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedProtoLimitsFeature { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedProtoLimitsFeature { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod proto_limits_feature { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum EnforceProtoLimits { PROTOLIMITSUNKNOWN = 0, LEGACYNOEXPLICITLIMITS = 1, PROTOLIMITS2026 = 2, } impl EnforceProtoLimits { pub fn from_i32(value: i32) -> Self { match value { 0 => EnforceProtoLimits::PROTOLIMITSUNKNOWN, 1 => EnforceProtoLimits::LEGACYNOEXPLICITLIMITS, 2 => EnforceProtoLimits::PROTOLIMITS2026, _ => EnforceProtoLimits::PROTOLIMITSUNKNOWN, } } } } } pub struct FeatureSetDefaults<'a> { accessor: crate::runtime::ProtoAccessor<'a>, defaults_start: Option, defaults_end: Option, minimum_edition_offset: Option, maximum_edition_offset: Option, } impl<'a> FeatureSetDefaults<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut defaults_start = None; let mut defaults_end = None; let mut minimum_edition_offset = None; let mut maximum_edition_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { if defaults_start.is_none() { defaults_start = Some(offset); } defaults_end = Some(offset); } if tag.field_number == 4 { minimum_edition_offset = Some(offset); } if tag.field_number == 5 { maximum_edition_offset = Some(offset); } } Ok(Self { accessor, defaults_start, defaults_end, minimum_edition_offset, maximum_edition_offset, }) } pub fn defaults(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.defaults_start, self.defaults_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(1, start, end), _ => self.accessor.iter_repeated(1), } } pub fn minimum_edition(&self) -> crate::runtime::Result { let offset = self.minimum_edition_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn minimum_edition_or_default(&self) -> crate::runtime::Result { self.minimum_edition().or(Ok(0)) } pub fn has_minimum_edition(&self) -> bool { self.minimum_edition_offset.is_some() } pub fn maximum_edition(&self) -> crate::runtime::Result { let offset = self.maximum_edition_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn maximum_edition_or_default(&self) -> crate::runtime::Result { self.maximum_edition().or(Ok(0)) } pub fn has_maximum_edition(&self) -> bool { self.maximum_edition_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FeatureSetDefaultsBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, defaults_written: bool, minimum_edition_written: bool, maximum_edition_written: bool, } impl<'b> FeatureSetDefaultsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSetDefaultsBuilder<'_> { FeatureSetDefaultsBuilder { builder: crate::runtime::ProtoBuilder::new(buf), defaults_written: false, minimum_edition_written: false, maximum_edition_written: false, } } pub fn defaults(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(1, value)?; self.defaults_written = true; Ok(self) } pub fn minimum_edition(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(4, value)?; self.minimum_edition_written = true; Ok(self) } pub fn maximum_edition(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(5, value)?; self.maximum_edition_written = true; Ok(self) } pub fn with(mut self, msg: &FeatureSetDefaults<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.defaults_written, 4 => self.minimum_edition_written, 5 => self.maximum_edition_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedFeatureSetDefaults { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedFeatureSetDefaults { type Reader<'a> = FeatureSetDefaults<'a>; fn reader(&self) -> FeatureSetDefaults<'_> { FeatureSetDefaults::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedFeatureSetDefaults { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedFeatureSetDefaults { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod feature_set_defaults { pub struct FeatureSetEditionDefault<'a> { accessor: crate::runtime::ProtoAccessor<'a>, edition_offset: Option, overridable_features_offset: Option, fixed_features_offset: Option, } impl<'a> FeatureSetEditionDefault<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut edition_offset = None; let mut overridable_features_offset = None; let mut fixed_features_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 3 { edition_offset = Some(offset); } if tag.field_number == 4 { overridable_features_offset = Some(offset); } if tag.field_number == 5 { fixed_features_offset = Some(offset); } } Ok(Self { accessor, edition_offset, overridable_features_offset, fixed_features_offset, }) } pub fn edition(&self) -> crate::runtime::Result { let offset = self.edition_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn edition_or_default(&self) -> crate::runtime::Result { self.edition().or(Ok(0)) } pub fn has_edition(&self) -> bool { self.edition_offset.is_some() } pub fn overridable_features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.overridable_features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn overridable_features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.overridable_features().or(Ok(&[])) } pub fn has_overridable_features(&self) -> bool { self.overridable_features_offset.is_some() } pub fn fixed_features(&self) -> crate::runtime::Result<&'a [u8]> { let offset = self.fixed_features_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } pub fn fixed_features_or_default(&self) -> crate::runtime::Result<&'a [u8]> { self.fixed_features().or(Ok(&[])) } pub fn has_fixed_features(&self) -> bool { self.fixed_features_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FeatureSetEditionDefaultBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, edition_written: bool, overridable_features_written: bool, fixed_features_written: bool, } impl<'b> FeatureSetEditionDefaultBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSetEditionDefaultBuilder<'_> { FeatureSetEditionDefaultBuilder { builder: crate::runtime::ProtoBuilder::new(buf), edition_written: false, overridable_features_written: false, fixed_features_written: false, } } pub fn edition(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(3, value)?; self.edition_written = true; Ok(self) } pub fn overridable_features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(4, value)?; self.overridable_features_written = true; Ok(self) } pub fn fixed_features(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(5, value)?; self.fixed_features_written = true; Ok(self) } pub fn with(mut self, msg: &FeatureSetEditionDefault<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 3 => self.edition_written, 4 => self.overridable_features_written, 5 => self.fixed_features_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedFeatureSetEditionDefault { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedFeatureSetEditionDefault { type Reader<'a> = FeatureSetEditionDefault<'a>; fn reader(&self) -> FeatureSetEditionDefault<'_> { FeatureSetEditionDefault::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedFeatureSetEditionDefault { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedFeatureSetEditionDefault { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } } pub struct SourceCodeInfo<'a> { accessor: crate::runtime::ProtoAccessor<'a>, location_start: Option, location_end: Option, } impl<'a> SourceCodeInfo<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut location_start = None; let mut location_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { if location_start.is_none() { location_start = Some(offset); } location_end = Some(offset); } } Ok(Self { accessor, location_start, location_end, }) } pub fn location(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.location_start, self.location_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(1, start, end), _ => self.accessor.iter_repeated(1), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct SourceCodeInfoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, location_written: bool, } impl<'b> SourceCodeInfoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> SourceCodeInfoBuilder<'_> { SourceCodeInfoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), location_written: false, } } pub fn location(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(1, value)?; self.location_written = true; Ok(self) } pub fn with(mut self, msg: &SourceCodeInfo<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.location_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedSourceCodeInfo { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedSourceCodeInfo { type Reader<'a> = SourceCodeInfo<'a>; fn reader(&self) -> SourceCodeInfo<'_> { SourceCodeInfo::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedSourceCodeInfo { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedSourceCodeInfo { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod source_code_info { pub struct Location<'a> { accessor: crate::runtime::ProtoAccessor<'a>, path_start: Option, path_end: Option, span_start: Option, span_end: Option, leading_comments_offset: Option, trailing_comments_offset: Option, leading_detached_comments_start: Option, leading_detached_comments_end: Option, } impl<'a> Location<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut path_start = None; let mut path_end = None; let mut span_start = None; let mut span_end = None; let mut leading_comments_offset = None; let mut trailing_comments_offset = None; let mut leading_detached_comments_start = None; let mut leading_detached_comments_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { if path_start.is_none() { path_start = Some(offset); } path_end = Some(offset); } if tag.field_number == 2 { if span_start.is_none() { span_start = Some(offset); } span_end = Some(offset); } if tag.field_number == 3 { leading_comments_offset = Some(offset); } if tag.field_number == 4 { trailing_comments_offset = Some(offset); } if tag.field_number == 6 { if leading_detached_comments_start.is_none() { leading_detached_comments_start = Some(offset); } leading_detached_comments_end = Some(offset); } } Ok(Self { accessor, path_start, path_end, span_start, span_end, leading_comments_offset, trailing_comments_offset, leading_detached_comments_start, leading_detached_comments_end, }) } pub fn path(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.path_start, self.path_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(1, start, end), _ => self.accessor.iter_repeated(1), } } pub fn span(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.span_start, self.span_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(2, start, end), _ => self.accessor.iter_repeated(2), } } pub fn leading_comments(&self) -> crate::runtime::Result<&'a str> { let offset = self.leading_comments_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn leading_comments_or_default(&self) -> crate::runtime::Result<&'a str> { self.leading_comments().or(Ok("")) } pub fn has_leading_comments(&self) -> bool { self.leading_comments_offset.is_some() } pub fn trailing_comments(&self) -> crate::runtime::Result<&'a str> { let offset = self.trailing_comments_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn trailing_comments_or_default(&self) -> crate::runtime::Result<&'a str> { self.trailing_comments().or(Ok("")) } pub fn has_trailing_comments(&self) -> bool { self.trailing_comments_offset.is_some() } pub fn leading_detached_comments(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.leading_detached_comments_start, self.leading_detached_comments_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(6, start, end), _ => self.accessor.iter_repeated(6), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct LocationBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, path_written: bool, span_written: bool, leading_comments_written: bool, trailing_comments_written: bool, leading_detached_comments_written: bool, } impl<'b> LocationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> LocationBuilder<'_> { LocationBuilder { builder: crate::runtime::ProtoBuilder::new(buf), path_written: false, span_written: false, leading_comments_written: false, trailing_comments_written: false, leading_detached_comments_written: false, } } pub fn path(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(1, value)?; self.path_written = true; Ok(self) } pub fn span(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(2, value)?; self.span_written = true; Ok(self) } pub fn leading_comments(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(3, value)?; self.leading_comments_written = true; Ok(self) } pub fn trailing_comments(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(4, value)?; self.trailing_comments_written = true; Ok(self) } pub fn leading_detached_comments(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(6, value)?; self.leading_detached_comments_written = true; Ok(self) } pub fn with(mut self, msg: &Location<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.path_written, 2 => self.span_written, 3 => self.leading_comments_written, 4 => self.trailing_comments_written, 6 => self.leading_detached_comments_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedLocation { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedLocation { type Reader<'a> = Location<'a>; fn reader(&self) -> Location<'_> { Location::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedLocation { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedLocation { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } } pub struct GeneratedCodeInfo<'a> { accessor: crate::runtime::ProtoAccessor<'a>, annotation_start: Option, annotation_end: Option, } impl<'a> GeneratedCodeInfo<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut annotation_start = None; let mut annotation_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { if annotation_start.is_none() { annotation_start = Some(offset); } annotation_end = Some(offset); } } Ok(Self { accessor, annotation_start, annotation_end, }) } pub fn annotation(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.annotation_start, self.annotation_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(1, start, end), _ => self.accessor.iter_repeated(1), } } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct GeneratedCodeInfoBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, annotation_written: bool, } impl<'b> GeneratedCodeInfoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> GeneratedCodeInfoBuilder<'_> { GeneratedCodeInfoBuilder { builder: crate::runtime::ProtoBuilder::new(buf), annotation_written: false, } } pub fn annotation(mut self, value: &[u8]) -> crate::runtime::Result { self.builder.write_bytes(1, value)?; self.annotation_written = true; Ok(self) } pub fn with(mut self, msg: &GeneratedCodeInfo<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.annotation_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedGeneratedCodeInfo { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedGeneratedCodeInfo { type Reader<'a> = GeneratedCodeInfo<'a>; fn reader(&self) -> GeneratedCodeInfo<'_> { GeneratedCodeInfo::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedGeneratedCodeInfo { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedGeneratedCodeInfo { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod generated_code_info { pub struct Annotation<'a> { accessor: crate::runtime::ProtoAccessor<'a>, path_start: Option, path_end: Option, source_file_offset: Option, begin_offset: Option, end_offset: Option, semantic_offset: Option, } impl<'a> Annotation<'a> { pub fn new(data: &'a [u8]) -> crate::runtime::Result { let accessor = crate::runtime::ProtoAccessor::new(data)?; let mut path_start = None; let mut path_end = None; let mut source_file_offset = None; let mut begin_offset = None; let mut end_offset = None; let mut semantic_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { if path_start.is_none() { path_start = Some(offset); } path_end = Some(offset); } if tag.field_number == 2 { source_file_offset = Some(offset); } if tag.field_number == 3 { begin_offset = Some(offset); } if tag.field_number == 4 { end_offset = Some(offset); } if tag.field_number == 5 { semantic_offset = Some(offset); } } Ok(Self { accessor, path_start, path_end, source_file_offset, begin_offset, end_offset, semantic_offset, }) } pub fn path(&self) -> crate::runtime::RepeatedFieldIterator<'a> { match (self.path_start, self.path_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(1, start, end), _ => self.accessor.iter_repeated(1), } } pub fn source_file(&self) -> crate::runtime::Result<&'a str> { let offset = self.source_file_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; str::from_utf8(bytes).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn source_file_or_default(&self) -> crate::runtime::Result<&'a str> { self.source_file().or(Ok("")) } pub fn has_source_file(&self) -> bool { self.source_file_offset.is_some() } pub fn begin(&self) -> crate::runtime::Result { let offset = self.begin_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn begin_or_default(&self) -> crate::runtime::Result { self.begin().or(Ok(0)) } pub fn has_begin(&self) -> bool { self.begin_offset.is_some() } pub fn end(&self) -> crate::runtime::Result { let offset = self.end_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn end_or_default(&self) -> crate::runtime::Result { self.end().or(Ok(0)) } pub fn has_end(&self) -> bool { self.end_offset.is_some() } pub fn semantic(&self) -> crate::runtime::Result { let offset = self.semantic_offset.ok_or(crate::runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; crate::runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::runtime::RotoError::WireFormatViolation) } pub fn semantic_or_default(&self) -> crate::runtime::Result { self.semantic().or(Ok(0)) } pub fn has_semantic(&self) -> bool { self.semantic_offset.is_some() } pub fn raw_fields(&self) -> crate::runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct AnnotationBuilder<'b> { builder: crate::runtime::ProtoBuilder<'b>, path_written: bool, source_file_written: bool, begin_written: bool, end_written: bool, semantic_written: bool, } impl<'b> AnnotationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> AnnotationBuilder<'_> { AnnotationBuilder { builder: crate::runtime::ProtoBuilder::new(buf), path_written: false, source_file_written: false, begin_written: false, end_written: false, semantic_written: false, } } pub fn path(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(1, value)?; self.path_written = true; Ok(self) } pub fn source_file(mut self, value: &str) -> crate::runtime::Result { self.builder.write_string(2, value)?; self.source_file_written = true; Ok(self) } pub fn begin(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(3, value)?; self.begin_written = true; Ok(self) } pub fn end(mut self, value: i32) -> crate::runtime::Result { self.builder.write_int32(4, value)?; self.end_written = true; Ok(self) } pub fn semantic(mut self, value: u64) -> crate::runtime::Result { self.builder.write_varint(5, value)?; self.semantic_written = true; Ok(self) } pub fn with(mut self, msg: &Annotation<'_>) -> crate::runtime::Result { for item in msg.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.path_written, 2 => self.source_file_written, 3 => self.begin_written, 4 => self.end_written, 5 => self.semantic_written, _ => false, }; if !is_written { self.builder.write_raw(raw_bytes)?; } } Ok(self) } pub fn finish(self) -> crate::runtime::Result<&'b mut [u8]> { self.builder.finish() } } pub struct OwnedAnnotation { pub data: bytes::Bytes, } impl crate::runtime::RotoOwned for OwnedAnnotation { type Reader<'a> = Annotation<'a>; fn reader(&self) -> Annotation<'_> { Annotation::new(&self.data).expect("failed to create reader") } } impl crate::runtime::RotoMessage for OwnedAnnotation { fn decode(buf: bytes::Bytes) -> crate::runtime::Result { Ok(OwnedAnnotation { data: buf }) } fn bytes(&self) -> bytes::Bytes { self.data.clone() } } pub mod annotation { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum Semantic { NONE = 0, SET = 1, ALIAS = 2, } impl Semantic { pub fn from_i32(value: i32) -> Self { match value { 0 => Semantic::NONE, 1 => Semantic::SET, 2 => Semantic::ALIAS, _ => Semantic::NONE, } } } } }