From f03e1afdbf152def25a6d352a9c4c42e97e02873 Mon Sep 17 00:00:00 2001 From: charles Date: Wed, 20 May 2026 08:09:11 -0700 Subject: [PATCH] Regenerate protobuf files --- .../src/google/protobuf/compiler/plugin.rs | 399 +- benches/src/google/protobuf/descriptor.rs | 3610 +++++--- benches/src/hackers.rs | 812 +- examples/hello_world/proto/hello.rs | 98 +- examples/no_std_test/src/helloworld.rs | 130 +- .../src/google/protobuf/compiler/plugin.rs | 783 ++ .../benches/src/google/protobuf/descriptor.rs | 7578 +++++++++++++++++ 7 files changed, 11967 insertions(+), 1443 deletions(-) create mode 100644 roto/benches/src/google/protobuf/compiler/plugin.rs create mode 100644 roto/benches/src/google/protobuf/descriptor.rs diff --git a/benches/src/google/protobuf/compiler/plugin.rs b/benches/src/google/protobuf/compiler/plugin.rs index 7e5b506..effdda2 100644 --- a/benches/src/google/protobuf/compiler/plugin.rs +++ b/benches/src/google/protobuf/compiler/plugin.rs @@ -1,13 +1,13 @@ // @generated by protoc-gen-roto — do not edit -#![allow(unused_imports)] - -use crate::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator}; -use std::str; - +#[allow(unused_imports)] +use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator, RotoMessage}; +use core::str; +#[cfg(feature = "alloc")] +use bytes::{Bytes, BytesMut, Buf, BufMut}; use crate::google::protobuf::descriptor; pub struct Version<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, major_offset: Option, minor_offset: Option, patch_offset: Option, @@ -15,8 +15,8 @@ pub struct Version<'a> { } impl<'a> Version<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut major_offset = None; let mut minor_offset = None; let mut patch_offset = None; @@ -38,38 +38,62 @@ suffix_offset, }) } - pub fn major(&self) -> crate::Result { - let offset = self.major_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn major(&self) -> roto_runtime::Result { + let offset = self.major_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn minor(&self) -> crate::Result { - let offset = self.minor_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn major_or_default(&self) -> roto_runtime::Result { + self.major().or(Ok(0)) } - pub fn patch(&self) -> crate::Result { - let offset = self.patch_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_major(&self) -> bool { self.major_offset.is_some() } + + pub fn minor(&self) -> roto_runtime::Result { + let offset = self.minor_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn suffix(&self) -> crate::Result<&'a str> { - let offset = self.suffix_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn minor_or_default(&self) -> roto_runtime::Result { + self.minor().or(Ok(0)) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_minor(&self) -> bool { self.minor_offset.is_some() } + + pub fn patch(&self) -> roto_runtime::Result { + let offset = self.patch_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn patch_or_default(&self) -> roto_runtime::Result { + self.patch().or(Ok(0)) + } + + pub fn has_patch(&self) -> bool { self.patch_offset.is_some() } + + pub fn suffix(&self) -> roto_runtime::Result<&'a str> { + let offset = self.suffix_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn suffix_or_default(&self) -> roto_runtime::Result<&'a str> { + self.suffix().or(Ok("")) + } + + pub fn has_suffix(&self) -> bool { self.suffix_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct VersionBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, major_written: bool, minor_written: bool, patch_written: bool, @@ -79,7 +103,7 @@ pub struct VersionBuilder<'b> { impl<'b> VersionBuilder<'b> { pub fn builder(buf: &mut [u8]) -> VersionBuilder<'_> { VersionBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), major_written: false, minor_written: false, patch_written: false, @@ -87,32 +111,32 @@ impl<'b> VersionBuilder<'b> { } } - pub fn major(mut self, value: i32) -> crate::Result { + pub fn major(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(1, value)?; self.major_written = true; Ok(self) } - pub fn minor(mut self, value: i32) -> crate::Result { + pub fn minor(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(2, value)?; self.minor_written = true; Ok(self) } - pub fn patch(mut self, value: i32) -> crate::Result { + pub fn patch(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(3, value)?; self.patch_written = true; Ok(self) } - pub fn suffix(mut self, value: &str) -> crate::Result { + pub fn suffix(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(4, value)?; self.suffix_written = true; Ok(self) } - pub fn with(mut self, msg: &Version<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &Version<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.major_written, @@ -128,13 +152,37 @@ impl<'b> VersionBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedVersion { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedVersion { + type Reader<'a> = Version<'a>; + fn reader(&self) -> Version<'_> { + Version::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedVersion { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedVersion { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct CodeGeneratorRequest<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, file_to_generate_start: Option, file_to_generate_end: Option, parameter_offset: Option, @@ -146,8 +194,8 @@ pub struct CodeGeneratorRequest<'a> { } impl<'a> CodeGeneratorRequest<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut file_to_generate_start = None; let mut file_to_generate_end = None; let mut parameter_offset = None; @@ -184,47 +232,59 @@ compiler_version_offset, }) } - pub fn file_to_generate(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn file_to_generate(&self) -> roto_runtime::RepeatedFieldIterator<'a> { match (self.file_to_generate_start, self.file_to_generate_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(1, start, end), _ => self.accessor.iter_repeated(1), } } - pub fn parameter(&self) -> crate::Result<&'a str> { - let offset = self.parameter_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn parameter(&self) -> roto_runtime::Result<&'a str> { + let offset = self.parameter_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn proto_file(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn parameter_or_default(&self) -> roto_runtime::Result<&'a str> { + self.parameter().or(Ok("")) + } + + pub fn has_parameter(&self) -> bool { self.parameter_offset.is_some() } + + pub fn proto_file(&self) -> roto_runtime::RepeatedFieldIterator<'a> { match (self.proto_file_start, self.proto_file_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(15, start, end), _ => self.accessor.iter_repeated(15), } } - pub fn source_file_descriptors(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn source_file_descriptors(&self) -> roto_runtime::RepeatedFieldIterator<'a> { match (self.source_file_descriptors_start, self.source_file_descriptors_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(17, start, end), _ => self.accessor.iter_repeated(17), } } - pub fn compiler_version(&self) -> crate::Result<&'a [u8]> { - let offset = self.compiler_version_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn compiler_version(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.compiler_version_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn compiler_version_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.compiler_version().or(Ok(&[])) + } + + pub fn has_compiler_version(&self) -> bool { self.compiler_version_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct CodeGeneratorRequestBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, file_to_generate_written: bool, parameter_written: bool, proto_file_written: bool, @@ -235,7 +295,7 @@ pub struct CodeGeneratorRequestBuilder<'b> { impl<'b> CodeGeneratorRequestBuilder<'b> { pub fn builder(buf: &mut [u8]) -> CodeGeneratorRequestBuilder<'_> { CodeGeneratorRequestBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), file_to_generate_written: false, parameter_written: false, proto_file_written: false, @@ -244,38 +304,38 @@ impl<'b> CodeGeneratorRequestBuilder<'b> { } } - pub fn file_to_generate(mut self, value: &str) -> crate::Result { + pub fn file_to_generate(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.file_to_generate_written = true; Ok(self) } - pub fn parameter(mut self, value: &str) -> crate::Result { + pub fn parameter(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(2, value)?; self.parameter_written = true; Ok(self) } - pub fn proto_file(mut self, value: &[u8]) -> crate::Result { + pub fn proto_file(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(15, value)?; self.proto_file_written = true; Ok(self) } - pub fn source_file_descriptors(mut self, value: &[u8]) -> crate::Result { + pub fn source_file_descriptors(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(17, value)?; self.source_file_descriptors_written = true; Ok(self) } - pub fn compiler_version(mut self, value: &[u8]) -> crate::Result { + pub fn compiler_version(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(3, value)?; self.compiler_version_written = true; Ok(self) } - pub fn with(mut self, msg: &CodeGeneratorRequest<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &CodeGeneratorRequest<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.file_to_generate_written, @@ -292,13 +352,37 @@ impl<'b> CodeGeneratorRequestBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedCodeGeneratorRequest { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedCodeGeneratorRequest { + type Reader<'a> = CodeGeneratorRequest<'a>; + fn reader(&self) -> CodeGeneratorRequest<'_> { + CodeGeneratorRequest::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedCodeGeneratorRequest { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedCodeGeneratorRequest { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct CodeGeneratorResponse<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, error_offset: Option, supported_features_offset: Option, minimum_edition_offset: Option, @@ -308,8 +392,8 @@ pub struct CodeGeneratorResponse<'a> { } impl<'a> CodeGeneratorResponse<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut error_offset = None; let mut supported_features_offset = None; let mut minimum_edition_offset = None; @@ -338,45 +422,69 @@ file_start, file_end, }) } - pub fn error(&self) -> crate::Result<&'a str> { - let offset = self.error_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn error(&self) -> roto_runtime::Result<&'a str> { + let offset = self.error_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn supported_features(&self) -> crate::Result { - let offset = self.supported_features_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn error_or_default(&self) -> roto_runtime::Result<&'a str> { + self.error().or(Ok("")) } - pub fn minimum_edition(&self) -> crate::Result { - let offset = self.minimum_edition_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_error(&self) -> bool { self.error_offset.is_some() } + + pub fn supported_features(&self) -> roto_runtime::Result { + let offset = self.supported_features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn maximum_edition(&self) -> crate::Result { - let offset = self.maximum_edition_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn supported_features_or_default(&self) -> roto_runtime::Result { + self.supported_features().or(Ok(0)) } - pub fn file(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn has_supported_features(&self) -> bool { self.supported_features_offset.is_some() } + + pub fn minimum_edition(&self) -> roto_runtime::Result { + let offset = self.minimum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn minimum_edition_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.maximum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn maximum_edition_or_default(&self) -> roto_runtime::Result { + self.maximum_edition().or(Ok(0)) + } + + pub fn has_maximum_edition(&self) -> bool { self.maximum_edition_offset.is_some() } + + pub fn file(&self) -> roto_runtime::RepeatedFieldIterator<'a> { match (self.file_start, self.file_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(15, start, end), _ => self.accessor.iter_repeated(15), } } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct CodeGeneratorResponseBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, error_written: bool, supported_features_written: bool, minimum_edition_written: bool, @@ -387,7 +495,7 @@ pub struct CodeGeneratorResponseBuilder<'b> { impl<'b> CodeGeneratorResponseBuilder<'b> { pub fn builder(buf: &mut [u8]) -> CodeGeneratorResponseBuilder<'_> { CodeGeneratorResponseBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), error_written: false, supported_features_written: false, minimum_edition_written: false, @@ -396,38 +504,38 @@ impl<'b> CodeGeneratorResponseBuilder<'b> { } } - pub fn error(mut self, value: &str) -> crate::Result { + pub fn error(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.error_written = true; Ok(self) } - pub fn supported_features(mut self, value: u64) -> crate::Result { + pub fn supported_features(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(2, value)?; self.supported_features_written = true; Ok(self) } - pub fn minimum_edition(mut self, value: i32) -> crate::Result { + pub fn minimum_edition(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(3, value)?; self.minimum_edition_written = true; Ok(self) } - pub fn maximum_edition(mut self, value: i32) -> crate::Result { + pub fn maximum_edition(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(4, value)?; self.maximum_edition_written = true; Ok(self) } - pub fn file(mut self, value: &[u8]) -> crate::Result { + pub fn file(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(15, value)?; self.file_written = true; Ok(self) } - pub fn with(mut self, msg: &CodeGeneratorResponse<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &CodeGeneratorResponse<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.error_written, @@ -444,11 +552,35 @@ impl<'b> CodeGeneratorResponseBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedCodeGeneratorResponse { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedCodeGeneratorResponse { + type Reader<'a> = CodeGeneratorResponse<'a>; + fn reader(&self) -> CodeGeneratorResponse<'_> { + CodeGeneratorResponse::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedCodeGeneratorResponse { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedCodeGeneratorResponse { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub mod code_generator_response { #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] @@ -470,7 +602,7 @@ impl Feature { } pub struct File<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, insertion_point_offset: Option, content_offset: Option, @@ -478,8 +610,8 @@ pub struct File<'a> { } impl<'a> File<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut insertion_point_offset = None; let mut content_offset = None; @@ -501,38 +633,62 @@ generated_code_info_offset, }) } - pub fn name(&self) -> crate::Result<&'a str> { - let offset = self.name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn insertion_point(&self) -> crate::Result<&'a str> { - let offset = self.insertion_point_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) } - pub fn content(&self) -> crate::Result<&'a str> { - let offset = self.content_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn insertion_point(&self) -> roto_runtime::Result<&'a str> { + let offset = self.insertion_point_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn generated_code_info(&self) -> crate::Result<&'a [u8]> { - let offset = self.generated_code_info_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn insertion_point_or_default(&self) -> roto_runtime::Result<&'a str> { + self.insertion_point().or(Ok("")) + } + + pub fn has_insertion_point(&self) -> bool { self.insertion_point_offset.is_some() } + + pub fn content(&self) -> roto_runtime::Result<&'a str> { + let offset = self.content_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn content_or_default(&self) -> roto_runtime::Result<&'a str> { + self.content().or(Ok("")) + } + + pub fn has_content(&self) -> bool { self.content_offset.is_some() } + + pub fn generated_code_info(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.generated_code_info_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn generated_code_info_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.generated_code_info().or(Ok(&[])) + } + + pub fn has_generated_code_info(&self) -> bool { self.generated_code_info_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FileBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, insertion_point_written: bool, content_written: bool, @@ -542,7 +698,7 @@ pub struct FileBuilder<'b> { impl<'b> FileBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileBuilder<'_> { FileBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, insertion_point_written: false, content_written: false, @@ -550,32 +706,32 @@ impl<'b> FileBuilder<'b> { } } - pub fn name(mut self, value: &str) -> crate::Result { + pub fn name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } - pub fn insertion_point(mut self, value: &str) -> crate::Result { + pub fn insertion_point(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(2, value)?; self.insertion_point_written = true; Ok(self) } - pub fn content(mut self, value: &str) -> crate::Result { + pub fn content(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(15, value)?; self.content_written = true; Ok(self) } - pub fn generated_code_info(mut self, value: &[u8]) -> crate::Result { + pub fn generated_code_info(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(16, value)?; self.generated_code_info_written = true; Ok(self) } - pub fn with(mut self, msg: &File<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &File<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -591,10 +747,37 @@ impl<'b> FileBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFile { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFile { + type Reader<'a> = File<'a>; + fn reader(&self) -> File<'_> { + File::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFile { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFile { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + } + +use crate::google::protobuf::descriptor; + diff --git a/benches/src/google/protobuf/descriptor.rs b/benches/src/google/protobuf/descriptor.rs index 47d11be..b79e624 100644 --- a/benches/src/google/protobuf/descriptor.rs +++ b/benches/src/google/protobuf/descriptor.rs @@ -1,9 +1,9 @@ // @generated by protoc-gen-roto — do not edit -#![allow(unused_imports)] - -use crate::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator}; -use std::str; - +#[allow(unused_imports)] +use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator, RotoMessage}; +use core::str; +#[cfg(feature = "alloc")] +use bytes::{Bytes, BytesMut, Buf, BufMut}; #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] @@ -66,14 +66,14 @@ impl SymbolVisibility { } pub struct FileDescriptorSet<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, file_start: Option, file_end: Option, } impl<'a> FileDescriptorSet<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut file_start = None; let mut file_end = None; for item in accessor.fields() { @@ -90,40 +90,40 @@ file_start, file_end, }) } - pub fn file(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn file(&self) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FileDescriptorSetBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, file_written: bool, } impl<'b> FileDescriptorSetBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileDescriptorSetBuilder<'_> { FileDescriptorSetBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), file_written: false, } } - pub fn file(mut self, value: &[u8]) -> crate::Result { + pub fn file(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(1, value)?; self.file_written = true; Ok(self) } - pub fn with(mut self, msg: &FileDescriptorSet<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &FileDescriptorSet<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.file_written, @@ -136,13 +136,37 @@ impl<'b> FileDescriptorSetBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFileDescriptorSet { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFileDescriptorSet { + type Reader<'a> = FileDescriptorSet<'a>; + fn reader(&self) -> FileDescriptorSet<'_> { + FileDescriptorSet::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFileDescriptorSet { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFileDescriptorSet { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct FileDescriptorProto<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, package_offset: Option, dependency_start: Option, @@ -168,8 +192,8 @@ pub struct FileDescriptorProto<'a> { } impl<'a> FileDescriptorProto<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut package_offset = None; let mut dependency_start = None; @@ -253,106 +277,142 @@ edition_offset, }) } - pub fn name(&self) -> crate::Result<&'a str> { - let offset = self.name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn package(&self) -> crate::Result<&'a str> { - let offset = self.package_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) } - pub fn dependency(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn package(&self) -> roto_runtime::Result<&'a str> { + let offset = self.package_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn package_or_default(&self) -> roto_runtime::Result<&'a str> { + self.package().or(Ok("")) + } + + pub fn has_package(&self) -> bool { self.package_offset.is_some() } + + pub fn dependency(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn public_dependency(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn weak_dependency(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn option_dependency(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn message_type(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn enum_type(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn service(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn extension(&self) -> roto_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::Result<&'a [u8]> { - let offset = self.options_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn source_code_info(&self) -> crate::Result<&'a [u8]> { - let offset = self.source_code_info_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn options_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.source_code_info_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn syntax(&self) -> crate::Result<&'a str> { - let offset = self.syntax_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn source_code_info_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.source_code_info().or(Ok(&[])) } - pub fn edition(&self) -> crate::Result { - let offset = self.edition_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_source_code_info(&self) -> bool { self.source_code_info_offset.is_some() } + + pub fn syntax(&self) -> roto_runtime::Result<&'a str> { + let offset = self.syntax_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn syntax_or_default(&self) -> roto_runtime::Result<&'a str> { + self.syntax().or(Ok("")) + } + + pub fn has_syntax(&self) -> bool { self.syntax_offset.is_some() } + + pub fn edition(&self) -> roto_runtime::Result { + let offset = self.edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn edition_or_default(&self) -> roto_runtime::Result { + self.edition().or(Ok(0)) + } + + pub fn has_edition(&self) -> bool { self.edition_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FileDescriptorProtoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, package_written: bool, dependency_written: bool, @@ -372,7 +432,7 @@ pub struct FileDescriptorProtoBuilder<'b> { impl<'b> FileDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileDescriptorProtoBuilder<'_> { FileDescriptorProtoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, package_written: false, dependency_written: false, @@ -390,92 +450,92 @@ impl<'b> FileDescriptorProtoBuilder<'b> { } } - pub fn name(mut self, value: &str) -> crate::Result { + pub fn name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } - pub fn package(mut self, value: &str) -> crate::Result { + pub fn package(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(2, value)?; self.package_written = true; Ok(self) } - pub fn dependency(mut self, value: &str) -> crate::Result { + pub fn dependency(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(3, value)?; self.dependency_written = true; Ok(self) } - pub fn public_dependency(mut self, value: i32) -> crate::Result { + pub fn public_dependency(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(10, value)?; self.public_dependency_written = true; Ok(self) } - pub fn weak_dependency(mut self, value: i32) -> crate::Result { + pub fn weak_dependency(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(11, value)?; self.weak_dependency_written = true; Ok(self) } - pub fn option_dependency(mut self, value: &str) -> crate::Result { + pub fn option_dependency(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(15, value)?; self.option_dependency_written = true; Ok(self) } - pub fn message_type(mut self, value: &[u8]) -> crate::Result { + pub fn message_type(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(4, value)?; self.message_type_written = true; Ok(self) } - pub fn enum_type(mut self, value: &[u8]) -> crate::Result { + pub fn enum_type(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(5, value)?; self.enum_type_written = true; Ok(self) } - pub fn service(mut self, value: &[u8]) -> crate::Result { + pub fn service(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(6, value)?; self.service_written = true; Ok(self) } - pub fn extension(mut self, value: &[u8]) -> crate::Result { + pub fn extension(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(7, value)?; self.extension_written = true; Ok(self) } - pub fn options(mut self, value: &[u8]) -> crate::Result { + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(8, value)?; self.options_written = true; Ok(self) } - pub fn source_code_info(mut self, value: &[u8]) -> crate::Result { + pub fn source_code_info(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(9, value)?; self.source_code_info_written = true; Ok(self) } - pub fn syntax(mut self, value: &str) -> crate::Result { + pub fn syntax(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(12, value)?; self.syntax_written = true; Ok(self) } - pub fn edition(mut self, value: u64) -> crate::Result { + pub fn edition(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(14, value)?; self.edition_written = true; Ok(self) } - pub fn with(mut self, msg: &FileDescriptorProto<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &FileDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -501,13 +561,37 @@ impl<'b> FileDescriptorProtoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFileDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFileDescriptorProto { + type Reader<'a> = FileDescriptorProto<'a>; + fn reader(&self) -> FileDescriptorProto<'_> { + FileDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFileDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFileDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct DescriptorProto<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, field_start: Option, field_end: Option, @@ -530,8 +614,8 @@ pub struct DescriptorProto<'a> { } impl<'a> DescriptorProto<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut field_start = None; let mut field_end = None; @@ -606,88 +690,106 @@ visibility_offset, }) } - pub fn name(&self) -> crate::Result<&'a str> { - let offset = self.name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn field(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn field(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn extension(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn nested_type(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn enum_type(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn extension_range(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn oneof_decl(&self) -> roto_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::Result<&'a [u8]> { - let offset = self.options_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn reserved_range(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn reserved_range(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn reserved_name(&self) -> roto_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::Result { - let offset = self.visibility_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn visibility(&self) -> roto_runtime::Result { + let offset = self.visibility_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn visibility_or_default(&self) -> roto_runtime::Result { + self.visibility().or(Ok(0)) + } + + pub fn has_visibility(&self) -> bool { self.visibility_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct DescriptorProtoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, field_written: bool, extension_written: bool, @@ -704,7 +806,7 @@ pub struct DescriptorProtoBuilder<'b> { impl<'b> DescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> DescriptorProtoBuilder<'_> { DescriptorProtoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, field_written: false, extension_written: false, @@ -719,74 +821,74 @@ impl<'b> DescriptorProtoBuilder<'b> { } } - pub fn name(mut self, value: &str) -> crate::Result { + pub fn name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } - pub fn field(mut self, value: &[u8]) -> crate::Result { + pub fn field(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(2, value)?; self.field_written = true; Ok(self) } - pub fn extension(mut self, value: &[u8]) -> crate::Result { + pub fn extension(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(6, value)?; self.extension_written = true; Ok(self) } - pub fn nested_type(mut self, value: &[u8]) -> crate::Result { + pub fn nested_type(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(3, value)?; self.nested_type_written = true; Ok(self) } - pub fn enum_type(mut self, value: &[u8]) -> crate::Result { + pub fn enum_type(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(4, value)?; self.enum_type_written = true; Ok(self) } - pub fn extension_range(mut self, value: &[u8]) -> crate::Result { + pub fn extension_range(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(5, value)?; self.extension_range_written = true; Ok(self) } - pub fn oneof_decl(mut self, value: &[u8]) -> crate::Result { + pub fn oneof_decl(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(8, value)?; self.oneof_decl_written = true; Ok(self) } - pub fn options(mut self, value: &[u8]) -> crate::Result { + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(7, value)?; self.options_written = true; Ok(self) } - pub fn reserved_range(mut self, value: &[u8]) -> crate::Result { + pub fn reserved_range(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(9, value)?; self.reserved_range_written = true; Ok(self) } - pub fn reserved_name(mut self, value: &str) -> crate::Result { + pub fn reserved_name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(10, value)?; self.reserved_name_written = true; Ok(self) } - pub fn visibility(mut self, value: u64) -> crate::Result { + pub fn visibility(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(11, value)?; self.visibility_written = true; Ok(self) } - pub fn with(mut self, msg: &DescriptorProto<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &DescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -809,22 +911,46 @@ impl<'b> DescriptorProtoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedDescriptorProto { + type Reader<'a> = DescriptorProto<'a>; + fn reader(&self) -> DescriptorProto<'_> { + DescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub mod descriptor_proto { pub struct ExtensionRange<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, start_offset: Option, end_offset: Option, options_offset: Option, } impl<'a> ExtensionRange<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut start_offset = None; let mut end_offset = None; let mut options_offset = None; @@ -843,32 +969,50 @@ options_offset, }) } - pub fn start(&self) -> crate::Result { - let offset = self.start_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn start(&self) -> roto_runtime::Result { + let offset = self.start_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn end(&self) -> crate::Result { - let offset = self.end_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn start_or_default(&self) -> roto_runtime::Result { + self.start().or(Ok(0)) } - pub fn options(&self) -> crate::Result<&'a [u8]> { - let offset = self.options_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_start(&self) -> bool { self.start_offset.is_some() } + + pub fn end(&self) -> roto_runtime::Result { + let offset = self.end_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } + + pub fn has_end(&self) -> bool { self.end_offset.is_some() } + + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ExtensionRangeBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, start_written: bool, end_written: bool, options_written: bool, @@ -877,33 +1021,33 @@ pub struct ExtensionRangeBuilder<'b> { impl<'b> ExtensionRangeBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ExtensionRangeBuilder<'_> { ExtensionRangeBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), start_written: false, end_written: false, options_written: false, } } - pub fn start(mut self, value: i32) -> crate::Result { + pub fn start(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(1, value)?; self.start_written = true; Ok(self) } - pub fn end(mut self, value: i32) -> crate::Result { + pub fn end(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(2, value)?; self.end_written = true; Ok(self) } - pub fn options(mut self, value: &[u8]) -> crate::Result { + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(3, value)?; self.options_written = true; Ok(self) } - pub fn with(mut self, msg: &ExtensionRange<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &ExtensionRange<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.start_written, @@ -918,20 +1062,44 @@ impl<'b> ExtensionRangeBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedExtensionRange { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedExtensionRange { + type Reader<'a> = ExtensionRange<'a>; + fn reader(&self) -> ExtensionRange<'_> { + ExtensionRange::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedExtensionRange { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedExtensionRange { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct ReservedRange<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, start_offset: Option, end_offset: Option, } impl<'a> ReservedRange<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut start_offset = None; let mut end_offset = None; for item in accessor.fields() { @@ -947,26 +1115,38 @@ end_offset, }) } - pub fn start(&self) -> crate::Result { - let offset = self.start_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn start(&self) -> roto_runtime::Result { + let offset = self.start_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn end(&self) -> crate::Result { - let offset = self.end_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn start_or_default(&self) -> roto_runtime::Result { + self.start().or(Ok(0)) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_start(&self) -> bool { self.start_offset.is_some() } + + pub fn end(&self) -> roto_runtime::Result { + let offset = self.end_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } + + pub fn has_end(&self) -> bool { self.end_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ReservedRangeBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, start_written: bool, end_written: bool, } @@ -974,26 +1154,26 @@ pub struct ReservedRangeBuilder<'b> { impl<'b> ReservedRangeBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ReservedRangeBuilder<'_> { ReservedRangeBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), start_written: false, end_written: false, } } - pub fn start(mut self, value: i32) -> crate::Result { + pub fn start(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(1, value)?; self.start_written = true; Ok(self) } - pub fn end(mut self, value: i32) -> crate::Result { + pub fn end(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(2, value)?; self.end_written = true; Ok(self) } - pub fn with(mut self, msg: &ReservedRange<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &ReservedRange<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.start_written, @@ -1007,15 +1187,39 @@ impl<'b> ReservedRangeBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedReservedRange { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedReservedRange { + type Reader<'a> = ReservedRange<'a>; + fn reader(&self) -> ReservedRange<'_> { + ReservedRange::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedReservedRange { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedReservedRange { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + } pub struct ExtensionRangeOptions<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, uninterpreted_option_start: Option, uninterpreted_option_end: Option, declaration_start: Option, @@ -1025,8 +1229,8 @@ pub struct ExtensionRangeOptions<'a> { } impl<'a> ExtensionRangeOptions<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; let mut declaration_start = None; @@ -1056,40 +1260,52 @@ verification_offset, }) } - pub fn uninterpreted_option(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn uninterpreted_option(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn declaration(&self) -> roto_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::Result<&'a [u8]> { - let offset = self.features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn features(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn verification(&self) -> crate::Result { - let offset = self.verification_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn verification(&self) -> roto_runtime::Result { + let offset = self.verification_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn verification_or_default(&self) -> roto_runtime::Result { + self.verification().or(Ok(0)) + } + + pub fn has_verification(&self) -> bool { self.verification_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ExtensionRangeOptionsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, uninterpreted_option_written: bool, declaration_written: bool, features_written: bool, @@ -1099,7 +1315,7 @@ pub struct ExtensionRangeOptionsBuilder<'b> { impl<'b> ExtensionRangeOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ExtensionRangeOptionsBuilder<'_> { ExtensionRangeOptionsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), uninterpreted_option_written: false, declaration_written: false, features_written: false, @@ -1107,32 +1323,32 @@ impl<'b> ExtensionRangeOptionsBuilder<'b> { } } - pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } - pub fn declaration(mut self, value: &[u8]) -> crate::Result { + pub fn declaration(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(2, value)?; self.declaration_written = true; Ok(self) } - pub fn features(mut self, value: &[u8]) -> crate::Result { + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(50, value)?; self.features_written = true; Ok(self) } - pub fn verification(mut self, value: u64) -> crate::Result { + pub fn verification(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(3, value)?; self.verification_written = true; Ok(self) } - pub fn with(mut self, msg: &ExtensionRangeOptions<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &ExtensionRangeOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 999 => self.uninterpreted_option_written, @@ -1148,11 +1364,35 @@ impl<'b> ExtensionRangeOptionsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedExtensionRangeOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedExtensionRangeOptions { + type Reader<'a> = ExtensionRangeOptions<'a>; + fn reader(&self) -> ExtensionRangeOptions<'_> { + ExtensionRangeOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedExtensionRangeOptions { + fn decode(buf: bytes::Bytes) -> roto_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)] @@ -1172,7 +1412,7 @@ impl VerificationState { } pub struct Declaration<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, number_offset: Option, full_name_offset: Option, type_offset: Option, @@ -1181,8 +1421,8 @@ pub struct Declaration<'a> { } impl<'a> Declaration<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut number_offset = None; let mut full_name_offset = None; let mut type_offset = None; @@ -1207,44 +1447,74 @@ repeated_offset, }) } - pub fn number(&self) -> crate::Result { - let offset = self.number_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn number(&self) -> roto_runtime::Result { + let offset = self.number_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn full_name(&self) -> crate::Result<&'a str> { - let offset = self.full_name_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn number_or_default(&self) -> roto_runtime::Result { + self.number().or(Ok(0)) } - pub fn r#type(&self) -> crate::Result<&'a str> { - let offset = self.type_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_number(&self) -> bool { self.number_offset.is_some() } + + pub fn full_name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.full_name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn reserved(&self) -> crate::Result { - let offset = self.reserved_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn full_name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.full_name().or(Ok("")) } - pub fn repeated(&self) -> crate::Result { - let offset = self.repeated_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_full_name(&self) -> bool { self.full_name_offset.is_some() } + + pub fn r#type(&self) -> roto_runtime::Result<&'a str> { + let offset = self.type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn r#type_or_default(&self) -> roto_runtime::Result<&'a str> { + self.r#type().or(Ok("")) + } + + pub fn has_type(&self) -> bool { self.type_offset.is_some() } + + pub fn reserved(&self) -> roto_runtime::Result { + let offset = self.reserved_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn reserved_or_default(&self) -> roto_runtime::Result { + self.reserved().or(Ok(false)) + } + + pub fn has_reserved(&self) -> bool { self.reserved_offset.is_some() } + + pub fn repeated(&self) -> roto_runtime::Result { + let offset = self.repeated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn repeated_or_default(&self) -> roto_runtime::Result { + self.repeated().or(Ok(false)) + } + + pub fn has_repeated(&self) -> bool { self.repeated_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct DeclarationBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, number_written: bool, full_name_written: bool, type_written: bool, @@ -1255,7 +1525,7 @@ pub struct DeclarationBuilder<'b> { impl<'b> DeclarationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> DeclarationBuilder<'_> { DeclarationBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), number_written: false, full_name_written: false, type_written: false, @@ -1264,38 +1534,38 @@ impl<'b> DeclarationBuilder<'b> { } } - pub fn number(mut self, value: i32) -> crate::Result { + pub fn number(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(1, value)?; self.number_written = true; Ok(self) } - pub fn full_name(mut self, value: &str) -> crate::Result { + pub fn full_name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(2, value)?; self.full_name_written = true; Ok(self) } - pub fn r#type(mut self, value: &str) -> crate::Result { + pub fn r#type(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(3, value)?; self.type_written = true; Ok(self) } - pub fn reserved(mut self, value: u64) -> crate::Result { + pub fn reserved(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(5, value)?; self.reserved_written = true; Ok(self) } - pub fn repeated(mut self, value: u64) -> crate::Result { + pub fn repeated(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(6, value)?; self.repeated_written = true; Ok(self) } - pub fn with(mut self, msg: &Declaration<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &Declaration<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.number_written, @@ -1312,15 +1582,39 @@ impl<'b> DeclarationBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedDeclaration { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedDeclaration { + type Reader<'a> = Declaration<'a>; + fn reader(&self) -> Declaration<'_> { + Declaration::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedDeclaration { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedDeclaration { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + } pub struct FieldDescriptorProto<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, number_offset: Option, label_offset: Option, @@ -1335,8 +1629,8 @@ pub struct FieldDescriptorProto<'a> { } impl<'a> FieldDescriptorProto<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut number_offset = None; let mut label_offset = None; @@ -1379,80 +1673,146 @@ proto3_optional_offset, }) } - pub fn name(&self) -> crate::Result<&'a str> { - let offset = self.name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn number(&self) -> crate::Result { - let offset = self.number_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) } - pub fn label(&self) -> crate::Result { - let offset = self.label_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn number(&self) -> roto_runtime::Result { + let offset = self.number_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn r#type(&self) -> crate::Result { - let offset = self.type_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn number_or_default(&self) -> roto_runtime::Result { + self.number().or(Ok(0)) } - pub fn type_name(&self) -> crate::Result<&'a str> { - let offset = self.type_name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_number(&self) -> bool { self.number_offset.is_some() } + + pub fn label(&self) -> roto_runtime::Result { + let offset = self.label_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn extendee(&self) -> crate::Result<&'a str> { - let offset = self.extendee_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn label_or_default(&self) -> roto_runtime::Result { + self.label().or(Ok(0)) } - pub fn default_value(&self) -> crate::Result<&'a str> { - let offset = self.default_value_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_label(&self) -> bool { self.label_offset.is_some() } + + pub fn r#type(&self) -> roto_runtime::Result { + let offset = self.type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn oneof_index(&self) -> crate::Result { - let offset = self.oneof_index_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn r#type_or_default(&self) -> roto_runtime::Result { + self.r#type().or(Ok(0)) } - pub fn json_name(&self) -> crate::Result<&'a str> { - let offset = self.json_name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_type(&self) -> bool { self.type_offset.is_some() } + + pub fn type_name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.type_name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn options(&self) -> crate::Result<&'a [u8]> { - let offset = self.options_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn type_name_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.extendee_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn extendee_or_default(&self) -> roto_runtime::Result<&'a str> { + self.extendee().or(Ok("")) + } + + pub fn has_extendee(&self) -> bool { self.extendee_offset.is_some() } + + pub fn default_value(&self) -> roto_runtime::Result<&'a str> { + let offset = self.default_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn default_value_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.oneof_index_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn oneof_index_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.json_name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn json_name_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn proto3_optional(&self) -> crate::Result { - let offset = self.proto3_optional_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn proto3_optional(&self) -> roto_runtime::Result { + let offset = self.proto3_optional_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn proto3_optional_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FieldDescriptorProtoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, number_written: bool, label_written: bool, @@ -1469,7 +1829,7 @@ pub struct FieldDescriptorProtoBuilder<'b> { impl<'b> FieldDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FieldDescriptorProtoBuilder<'_> { FieldDescriptorProtoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, number_written: false, label_written: false, @@ -1484,74 +1844,74 @@ impl<'b> FieldDescriptorProtoBuilder<'b> { } } - pub fn name(mut self, value: &str) -> crate::Result { + pub fn name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } - pub fn number(mut self, value: i32) -> crate::Result { + pub fn number(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(3, value)?; self.number_written = true; Ok(self) } - pub fn label(mut self, value: u64) -> crate::Result { + pub fn label(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(4, value)?; self.label_written = true; Ok(self) } - pub fn r#type(mut self, value: u64) -> crate::Result { + pub fn r#type(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(5, value)?; self.type_written = true; Ok(self) } - pub fn type_name(mut self, value: &str) -> crate::Result { + pub fn type_name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(6, value)?; self.type_name_written = true; Ok(self) } - pub fn extendee(mut self, value: &str) -> crate::Result { + pub fn extendee(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(2, value)?; self.extendee_written = true; Ok(self) } - pub fn default_value(mut self, value: &str) -> crate::Result { + pub fn default_value(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(7, value)?; self.default_value_written = true; Ok(self) } - pub fn oneof_index(mut self, value: i32) -> crate::Result { + pub fn oneof_index(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(9, value)?; self.oneof_index_written = true; Ok(self) } - pub fn json_name(mut self, value: &str) -> crate::Result { + pub fn json_name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(10, value)?; self.json_name_written = true; Ok(self) } - pub fn options(mut self, value: &[u8]) -> crate::Result { + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(8, value)?; self.options_written = true; Ok(self) } - pub fn proto3_optional(mut self, value: u64) -> crate::Result { + pub fn proto3_optional(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(17, value)?; self.proto3_optional_written = true; Ok(self) } - pub fn with(mut self, msg: &FieldDescriptorProto<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &FieldDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -1574,11 +1934,35 @@ impl<'b> FieldDescriptorProtoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFieldDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFieldDescriptorProto { + type Reader<'a> = FieldDescriptorProto<'a>; + fn reader(&self) -> FieldDescriptorProto<'_> { + FieldDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFieldDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_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)] @@ -1653,14 +2037,14 @@ impl Label { } pub struct OneofDescriptorProto<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, options_offset: Option, } impl<'a> OneofDescriptorProto<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut options_offset = None; for item in accessor.fields() { @@ -1676,26 +2060,38 @@ options_offset, }) } - pub fn name(&self) -> crate::Result<&'a str> { - let offset = self.name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn options(&self) -> crate::Result<&'a [u8]> { - let offset = self.options_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct OneofDescriptorProtoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, options_written: bool, } @@ -1703,26 +2099,26 @@ pub struct OneofDescriptorProtoBuilder<'b> { impl<'b> OneofDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> OneofDescriptorProtoBuilder<'_> { OneofDescriptorProtoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, options_written: false, } } - pub fn name(mut self, value: &str) -> crate::Result { + pub fn name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } - pub fn options(mut self, value: &[u8]) -> crate::Result { + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(2, value)?; self.options_written = true; Ok(self) } - pub fn with(mut self, msg: &OneofDescriptorProto<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &OneofDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -1736,13 +2132,37 @@ impl<'b> OneofDescriptorProtoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedOneofDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedOneofDescriptorProto { + type Reader<'a> = OneofDescriptorProto<'a>; + fn reader(&self) -> OneofDescriptorProto<'_> { + OneofDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedOneofDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedOneofDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct EnumDescriptorProto<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, value_start: Option, value_end: Option, @@ -1755,8 +2175,8 @@ pub struct EnumDescriptorProto<'a> { } impl<'a> EnumDescriptorProto<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut value_start = None; let mut value_end = None; @@ -1796,53 +2216,71 @@ visibility_offset, }) } - pub fn name(&self) -> crate::Result<&'a str> { - let offset = self.name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn value(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn value(&self) -> roto_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::Result<&'a [u8]> { - let offset = self.options_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn reserved_range(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn reserved_range(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn reserved_name(&self) -> roto_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::Result { - let offset = self.visibility_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn visibility(&self) -> roto_runtime::Result { + let offset = self.visibility_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn visibility_or_default(&self) -> roto_runtime::Result { + self.visibility().or(Ok(0)) + } + + pub fn has_visibility(&self) -> bool { self.visibility_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumDescriptorProtoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, value_written: bool, options_written: bool, @@ -1854,7 +2292,7 @@ pub struct EnumDescriptorProtoBuilder<'b> { impl<'b> EnumDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumDescriptorProtoBuilder<'_> { EnumDescriptorProtoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, value_written: false, options_written: false, @@ -1864,44 +2302,44 @@ impl<'b> EnumDescriptorProtoBuilder<'b> { } } - pub fn name(mut self, value: &str) -> crate::Result { + pub fn name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } - pub fn value(mut self, value: &[u8]) -> crate::Result { + pub fn value(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(2, value)?; self.value_written = true; Ok(self) } - pub fn options(mut self, value: &[u8]) -> crate::Result { + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(3, value)?; self.options_written = true; Ok(self) } - pub fn reserved_range(mut self, value: &[u8]) -> crate::Result { + pub fn reserved_range(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(4, value)?; self.reserved_range_written = true; Ok(self) } - pub fn reserved_name(mut self, value: &str) -> crate::Result { + pub fn reserved_name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(5, value)?; self.reserved_name_written = true; Ok(self) } - pub fn visibility(mut self, value: u64) -> crate::Result { + pub fn visibility(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(6, value)?; self.visibility_written = true; Ok(self) } - pub fn with(mut self, msg: &EnumDescriptorProto<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &EnumDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -1919,21 +2357,45 @@ impl<'b> EnumDescriptorProtoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedEnumDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumDescriptorProto { + type Reader<'a> = EnumDescriptorProto<'a>; + fn reader(&self) -> EnumDescriptorProto<'_> { + EnumDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_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::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, start_offset: Option, end_offset: Option, } impl<'a> EnumReservedRange<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut start_offset = None; let mut end_offset = None; for item in accessor.fields() { @@ -1949,26 +2411,38 @@ end_offset, }) } - pub fn start(&self) -> crate::Result { - let offset = self.start_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn start(&self) -> roto_runtime::Result { + let offset = self.start_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn end(&self) -> crate::Result { - let offset = self.end_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn start_or_default(&self) -> roto_runtime::Result { + self.start().or(Ok(0)) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_start(&self) -> bool { self.start_offset.is_some() } + + pub fn end(&self) -> roto_runtime::Result { + let offset = self.end_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } + + pub fn has_end(&self) -> bool { self.end_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumReservedRangeBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, start_written: bool, end_written: bool, } @@ -1976,26 +2450,26 @@ pub struct EnumReservedRangeBuilder<'b> { impl<'b> EnumReservedRangeBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumReservedRangeBuilder<'_> { EnumReservedRangeBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), start_written: false, end_written: false, } } - pub fn start(mut self, value: i32) -> crate::Result { + pub fn start(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(1, value)?; self.start_written = true; Ok(self) } - pub fn end(mut self, value: i32) -> crate::Result { + pub fn end(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(2, value)?; self.end_written = true; Ok(self) } - pub fn with(mut self, msg: &EnumReservedRange<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &EnumReservedRange<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.start_written, @@ -2009,23 +2483,47 @@ impl<'b> EnumReservedRangeBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedEnumReservedRange { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumReservedRange { + type Reader<'a> = EnumReservedRange<'a>; + fn reader(&self) -> EnumReservedRange<'_> { + EnumReservedRange::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumReservedRange { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEnumReservedRange { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + } pub struct EnumValueDescriptorProto<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, number_offset: Option, options_offset: Option, } impl<'a> EnumValueDescriptorProto<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut number_offset = None; let mut options_offset = None; @@ -2044,32 +2542,50 @@ options_offset, }) } - pub fn name(&self) -> crate::Result<&'a str> { - let offset = self.name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn number(&self) -> crate::Result { - let offset = self.number_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) } - pub fn options(&self) -> crate::Result<&'a [u8]> { - let offset = self.options_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn number(&self) -> roto_runtime::Result { + let offset = self.number_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn number_or_default(&self) -> roto_runtime::Result { + self.number().or(Ok(0)) + } + + pub fn has_number(&self) -> bool { self.number_offset.is_some() } + + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumValueDescriptorProtoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, number_written: bool, options_written: bool, @@ -2078,33 +2594,33 @@ pub struct EnumValueDescriptorProtoBuilder<'b> { impl<'b> EnumValueDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumValueDescriptorProtoBuilder<'_> { EnumValueDescriptorProtoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, number_written: false, options_written: false, } } - pub fn name(mut self, value: &str) -> crate::Result { + pub fn name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } - pub fn number(mut self, value: i32) -> crate::Result { + pub fn number(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(2, value)?; self.number_written = true; Ok(self) } - pub fn options(mut self, value: &[u8]) -> crate::Result { + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(3, value)?; self.options_written = true; Ok(self) } - pub fn with(mut self, msg: &EnumValueDescriptorProto<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &EnumValueDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -2119,13 +2635,37 @@ impl<'b> EnumValueDescriptorProtoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedEnumValueDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumValueDescriptorProto { + type Reader<'a> = EnumValueDescriptorProto<'a>; + fn reader(&self) -> EnumValueDescriptorProto<'_> { + EnumValueDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumValueDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEnumValueDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct ServiceDescriptorProto<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, method_start: Option, method_end: Option, @@ -2133,8 +2673,8 @@ pub struct ServiceDescriptorProto<'a> { } impl<'a> ServiceDescriptorProto<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut method_start = None; let mut method_end = None; @@ -2157,33 +2697,45 @@ options_offset, }) } - pub fn name(&self) -> crate::Result<&'a str> { - let offset = self.name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn method(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn method(&self) -> roto_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::Result<&'a [u8]> { - let offset = self.options_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ServiceDescriptorProtoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, method_written: bool, options_written: bool, @@ -2192,33 +2744,33 @@ pub struct ServiceDescriptorProtoBuilder<'b> { impl<'b> ServiceDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ServiceDescriptorProtoBuilder<'_> { ServiceDescriptorProtoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, method_written: false, options_written: false, } } - pub fn name(mut self, value: &str) -> crate::Result { + pub fn name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } - pub fn method(mut self, value: &[u8]) -> crate::Result { + pub fn method(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(2, value)?; self.method_written = true; Ok(self) } - pub fn options(mut self, value: &[u8]) -> crate::Result { + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(3, value)?; self.options_written = true; Ok(self) } - pub fn with(mut self, msg: &ServiceDescriptorProto<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &ServiceDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -2233,13 +2785,37 @@ impl<'b> ServiceDescriptorProtoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedServiceDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedServiceDescriptorProto { + type Reader<'a> = ServiceDescriptorProto<'a>; + fn reader(&self) -> ServiceDescriptorProto<'_> { + ServiceDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedServiceDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedServiceDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct MethodDescriptorProto<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, input_type_offset: Option, output_type_offset: Option, @@ -2249,8 +2825,8 @@ pub struct MethodDescriptorProto<'a> { } impl<'a> MethodDescriptorProto<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_offset = None; let mut input_type_offset = None; let mut output_type_offset = None; @@ -2278,50 +2854,86 @@ server_streaming_offset, }) } - pub fn name(&self) -> crate::Result<&'a str> { - let offset = self.name_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn input_type(&self) -> crate::Result<&'a str> { - let offset = self.input_type_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) } - pub fn output_type(&self) -> crate::Result<&'a str> { - let offset = self.output_type_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn input_type(&self) -> roto_runtime::Result<&'a str> { + let offset = self.input_type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn options(&self) -> crate::Result<&'a [u8]> { - let offset = self.options_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn input_type_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.output_type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn output_type_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn client_streaming(&self) -> crate::Result { - let offset = self.client_streaming_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) } - pub fn server_streaming(&self) -> crate::Result { - let offset = self.server_streaming_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn client_streaming(&self) -> roto_runtime::Result { + let offset = self.client_streaming_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn client_streaming_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.server_streaming_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn server_streaming_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct MethodDescriptorProtoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, input_type_written: bool, output_type_written: bool, @@ -2333,7 +2945,7 @@ pub struct MethodDescriptorProtoBuilder<'b> { impl<'b> MethodDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> MethodDescriptorProtoBuilder<'_> { MethodDescriptorProtoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, input_type_written: false, output_type_written: false, @@ -2343,44 +2955,44 @@ impl<'b> MethodDescriptorProtoBuilder<'b> { } } - pub fn name(mut self, value: &str) -> crate::Result { + pub fn name(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_written = true; Ok(self) } - pub fn input_type(mut self, value: &str) -> crate::Result { + pub fn input_type(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(2, value)?; self.input_type_written = true; Ok(self) } - pub fn output_type(mut self, value: &str) -> crate::Result { + pub fn output_type(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(3, value)?; self.output_type_written = true; Ok(self) } - pub fn options(mut self, value: &[u8]) -> crate::Result { + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(4, value)?; self.options_written = true; Ok(self) } - pub fn client_streaming(mut self, value: u64) -> crate::Result { + pub fn client_streaming(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(5, value)?; self.client_streaming_written = true; Ok(self) } - pub fn server_streaming(mut self, value: u64) -> crate::Result { + pub fn server_streaming(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(6, value)?; self.server_streaming_written = true; Ok(self) } - pub fn with(mut self, msg: &MethodDescriptorProto<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &MethodDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -2398,13 +3010,37 @@ impl<'b> MethodDescriptorProtoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedMethodDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedMethodDescriptorProto { + type Reader<'a> = MethodDescriptorProto<'a>; + fn reader(&self) -> MethodDescriptorProto<'_> { + MethodDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedMethodDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedMethodDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct FileOptions<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, java_package_offset: Option, java_outer_classname_offset: Option, java_multiple_files_offset: Option, @@ -2430,8 +3066,8 @@ pub struct FileOptions<'a> { } impl<'a> FileOptions<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut java_package_offset = None; let mut java_outer_classname_offset = None; let mut java_multiple_files_offset = None; @@ -2508,141 +3144,261 @@ uninterpreted_option_start, uninterpreted_option_end, }) } - pub fn java_package(&self) -> crate::Result<&'a str> { - let offset = self.java_package_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn java_package(&self) -> roto_runtime::Result<&'a str> { + let offset = self.java_package_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn java_outer_classname(&self) -> crate::Result<&'a str> { - let offset = self.java_outer_classname_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn java_package_or_default(&self) -> roto_runtime::Result<&'a str> { + self.java_package().or(Ok("")) } - pub fn java_multiple_files(&self) -> crate::Result { - let offset = self.java_multiple_files_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_java_package(&self) -> bool { self.java_package_offset.is_some() } + + pub fn java_outer_classname(&self) -> roto_runtime::Result<&'a str> { + let offset = self.java_outer_classname_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn java_generate_equals_and_hash(&self) -> crate::Result { - let offset = self.java_generate_equals_and_hash_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn java_outer_classname_or_default(&self) -> roto_runtime::Result<&'a str> { + self.java_outer_classname().or(Ok("")) } - pub fn java_string_check_utf8(&self) -> crate::Result { - let offset = self.java_string_check_utf8_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_java_outer_classname(&self) -> bool { self.java_outer_classname_offset.is_some() } + + pub fn java_multiple_files(&self) -> roto_runtime::Result { + let offset = self.java_multiple_files_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn optimize_for(&self) -> crate::Result { - let offset = self.optimize_for_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn java_multiple_files_or_default(&self) -> roto_runtime::Result { + self.java_multiple_files().or(Ok(false)) } - pub fn go_package(&self) -> crate::Result<&'a str> { - let offset = self.go_package_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_java_multiple_files(&self) -> bool { self.java_multiple_files_offset.is_some() } + + pub fn java_generate_equals_and_hash(&self) -> roto_runtime::Result { + let offset = self.java_generate_equals_and_hash_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn cc_generic_services(&self) -> crate::Result { - let offset = self.cc_generic_services_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn java_generate_equals_and_hash_or_default(&self) -> roto_runtime::Result { + self.java_generate_equals_and_hash().or(Ok(false)) } - pub fn java_generic_services(&self) -> crate::Result { - let offset = self.java_generic_services_offset.ok_or(crate::RotoError::FieldNotFound)?; + 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) -> roto_runtime::Result { + let offset = self.java_string_check_utf8_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn py_generic_services(&self) -> crate::Result { - let offset = self.py_generic_services_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn java_string_check_utf8_or_default(&self) -> roto_runtime::Result { + self.java_string_check_utf8().or(Ok(false)) } - pub fn deprecated(&self) -> crate::Result { - let offset = self.deprecated_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_java_string_check_utf8(&self) -> bool { self.java_string_check_utf8_offset.is_some() } + + pub fn optimize_for(&self) -> roto_runtime::Result { + let offset = self.optimize_for_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn cc_enable_arenas(&self) -> crate::Result { - let offset = self.cc_enable_arenas_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn optimize_for_or_default(&self) -> roto_runtime::Result { + self.optimize_for().or(Ok(0)) } - pub fn objc_class_prefix(&self) -> crate::Result<&'a str> { - let offset = self.objc_class_prefix_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_optimize_for(&self) -> bool { self.optimize_for_offset.is_some() } + + pub fn go_package(&self) -> roto_runtime::Result<&'a str> { + let offset = self.go_package_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn csharp_namespace(&self) -> crate::Result<&'a str> { - let offset = self.csharp_namespace_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn go_package_or_default(&self) -> roto_runtime::Result<&'a str> { + self.go_package().or(Ok("")) } - pub fn swift_prefix(&self) -> crate::Result<&'a str> { - let offset = self.swift_prefix_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_go_package(&self) -> bool { self.go_package_offset.is_some() } + + pub fn cc_generic_services(&self) -> roto_runtime::Result { + let offset = self.cc_generic_services_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn php_class_prefix(&self) -> crate::Result<&'a str> { - let offset = self.php_class_prefix_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn cc_generic_services_or_default(&self) -> roto_runtime::Result { + self.cc_generic_services().or(Ok(false)) } - pub fn php_namespace(&self) -> crate::Result<&'a str> { - let offset = self.php_namespace_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_cc_generic_services(&self) -> bool { self.cc_generic_services_offset.is_some() } + + pub fn java_generic_services(&self) -> roto_runtime::Result { + let offset = self.java_generic_services_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn php_metadata_namespace(&self) -> crate::Result<&'a str> { - let offset = self.php_metadata_namespace_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn java_generic_services_or_default(&self) -> roto_runtime::Result { + self.java_generic_services().or(Ok(false)) } - pub fn ruby_package(&self) -> crate::Result<&'a str> { - let offset = self.ruby_package_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_java_generic_services(&self) -> bool { self.java_generic_services_offset.is_some() } + + pub fn py_generic_services(&self) -> roto_runtime::Result { + let offset = self.py_generic_services_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn features(&self) -> crate::Result<&'a [u8]> { - let offset = self.features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn py_generic_services_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn cc_enable_arenas(&self) -> roto_runtime::Result { + let offset = self.cc_enable_arenas_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn cc_enable_arenas_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.objc_class_prefix_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn objc_class_prefix_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.csharp_namespace_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn csharp_namespace_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.swift_prefix_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn swift_prefix_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.php_class_prefix_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn php_class_prefix_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.php_namespace_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn php_namespace_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.php_metadata_namespace_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn php_metadata_namespace_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.ruby_package_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn ruby_package_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn uninterpreted_option(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FileOptionsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, java_package_written: bool, java_outer_classname_written: bool, java_multiple_files_written: bool, @@ -2669,7 +3425,7 @@ pub struct FileOptionsBuilder<'b> { impl<'b> FileOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileOptionsBuilder<'_> { FileOptionsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), java_package_written: false, java_outer_classname_written: false, java_multiple_files_written: false, @@ -2694,134 +3450,134 @@ impl<'b> FileOptionsBuilder<'b> { } } - pub fn java_package(mut self, value: &str) -> crate::Result { + pub fn java_package(mut self, value: &str) -> roto_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::Result { + pub fn java_outer_classname(mut self, value: &str) -> roto_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::Result { + pub fn java_multiple_files(mut self, value: u64) -> roto_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::Result { + pub fn java_generate_equals_and_hash(mut self, value: u64) -> roto_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::Result { + pub fn java_string_check_utf8(mut self, value: u64) -> roto_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::Result { + pub fn optimize_for(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(9, value)?; self.optimize_for_written = true; Ok(self) } - pub fn go_package(mut self, value: &str) -> crate::Result { + pub fn go_package(mut self, value: &str) -> roto_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::Result { + pub fn cc_generic_services(mut self, value: u64) -> roto_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::Result { + pub fn java_generic_services(mut self, value: u64) -> roto_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::Result { + pub fn py_generic_services(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(18, value)?; self.py_generic_services_written = true; Ok(self) } - pub fn deprecated(mut self, value: u64) -> crate::Result { + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(23, value)?; self.deprecated_written = true; Ok(self) } - pub fn cc_enable_arenas(mut self, value: u64) -> crate::Result { + pub fn cc_enable_arenas(mut self, value: u64) -> roto_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::Result { + pub fn objc_class_prefix(mut self, value: &str) -> roto_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::Result { + pub fn csharp_namespace(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(37, value)?; self.csharp_namespace_written = true; Ok(self) } - pub fn swift_prefix(mut self, value: &str) -> crate::Result { + pub fn swift_prefix(mut self, value: &str) -> roto_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::Result { + pub fn php_class_prefix(mut self, value: &str) -> roto_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::Result { + pub fn php_namespace(mut self, value: &str) -> roto_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::Result { + pub fn php_metadata_namespace(mut self, value: &str) -> roto_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::Result { + pub fn ruby_package(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(45, value)?; self.ruby_package_written = true; Ok(self) } - pub fn features(mut self, value: &[u8]) -> crate::Result { + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(50, value)?; self.features_written = true; Ok(self) } - pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } - pub fn with(mut self, msg: &FileOptions<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &FileOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.java_package_written, @@ -2854,11 +3610,35 @@ impl<'b> FileOptionsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFileOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFileOptions { + type Reader<'a> = FileOptions<'a>; + fn reader(&self) -> FileOptions<'_> { + FileOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFileOptions { + fn decode(buf: bytes::Bytes) -> roto_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)] @@ -2883,7 +3663,7 @@ impl OptimizeMode { } pub struct MessageOptions<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, message_set_wire_format_offset: Option, no_standard_descriptor_accessor_offset: Option, deprecated_offset: Option, @@ -2895,8 +3675,8 @@ pub struct MessageOptions<'a> { } impl<'a> MessageOptions<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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; @@ -2931,57 +3711,93 @@ uninterpreted_option_start, uninterpreted_option_end, }) } - pub fn message_set_wire_format(&self) -> crate::Result { - let offset = self.message_set_wire_format_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn message_set_wire_format(&self) -> roto_runtime::Result { + let offset = self.message_set_wire_format_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn no_standard_descriptor_accessor(&self) -> crate::Result { - let offset = self.no_standard_descriptor_accessor_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn message_set_wire_format_or_default(&self) -> roto_runtime::Result { + self.message_set_wire_format().or(Ok(false)) } - pub fn deprecated(&self) -> crate::Result { - let offset = self.deprecated_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_message_set_wire_format(&self) -> bool { self.message_set_wire_format_offset.is_some() } + + pub fn no_standard_descriptor_accessor(&self) -> roto_runtime::Result { + let offset = self.no_standard_descriptor_accessor_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn map_entry(&self) -> crate::Result { - let offset = self.map_entry_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn no_standard_descriptor_accessor_or_default(&self) -> roto_runtime::Result { + self.no_standard_descriptor_accessor().or(Ok(false)) } - pub fn deprecated_legacy_json_field_conflicts(&self) -> crate::Result { - let offset = self.deprecated_legacy_json_field_conflicts_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_no_standard_descriptor_accessor(&self) -> bool { self.no_standard_descriptor_accessor_offset.is_some() } + + pub fn deprecated(&self) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn features(&self) -> crate::Result<&'a [u8]> { - let offset = self.features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn map_entry(&self) -> roto_runtime::Result { + let offset = self.map_entry_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn map_entry_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_legacy_json_field_conflicts_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_legacy_json_field_conflicts_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn uninterpreted_option(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct MessageOptionsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, message_set_wire_format_written: bool, no_standard_descriptor_accessor_written: bool, deprecated_written: bool, @@ -2994,7 +3810,7 @@ pub struct MessageOptionsBuilder<'b> { impl<'b> MessageOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> MessageOptionsBuilder<'_> { MessageOptionsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), message_set_wire_format_written: false, no_standard_descriptor_accessor_written: false, deprecated_written: false, @@ -3005,50 +3821,50 @@ impl<'b> MessageOptionsBuilder<'b> { } } - pub fn message_set_wire_format(mut self, value: u64) -> crate::Result { + pub fn message_set_wire_format(mut self, value: u64) -> roto_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::Result { + pub fn no_standard_descriptor_accessor(mut self, value: u64) -> roto_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::Result { + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(3, value)?; self.deprecated_written = true; Ok(self) } - pub fn map_entry(mut self, value: u64) -> crate::Result { + pub fn map_entry(mut self, value: u64) -> roto_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::Result { + pub fn deprecated_legacy_json_field_conflicts(mut self, value: u64) -> roto_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::Result { + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(12, value)?; self.features_written = true; Ok(self) } - pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } - pub fn with(mut self, msg: &MessageOptions<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &MessageOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.message_set_wire_format_written, @@ -3067,13 +3883,37 @@ impl<'b> MessageOptionsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedMessageOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedMessageOptions { + type Reader<'a> = MessageOptions<'a>; + fn reader(&self) -> MessageOptions<'_> { + MessageOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedMessageOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedMessageOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct FieldOptions<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, ctype_offset: Option, packed_offset: Option, jstype_offset: Option, @@ -3094,8 +3934,8 @@ pub struct FieldOptions<'a> { } impl<'a> FieldOptions<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut ctype_offset = None; let mut packed_offset = None; let mut jstype_offset = None; @@ -3159,101 +3999,167 @@ uninterpreted_option_start, uninterpreted_option_end, }) } - pub fn ctype(&self) -> crate::Result { - let offset = self.ctype_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn ctype(&self) -> roto_runtime::Result { + let offset = self.ctype_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn packed(&self) -> crate::Result { - let offset = self.packed_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn ctype_or_default(&self) -> roto_runtime::Result { + self.ctype().or(Ok(0)) } - pub fn jstype(&self) -> crate::Result { - let offset = self.jstype_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_ctype(&self) -> bool { self.ctype_offset.is_some() } + + pub fn packed(&self) -> roto_runtime::Result { + let offset = self.packed_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn lazy(&self) -> crate::Result { - let offset = self.lazy_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn packed_or_default(&self) -> roto_runtime::Result { + self.packed().or(Ok(false)) } - pub fn unverified_lazy(&self) -> crate::Result { - let offset = self.unverified_lazy_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_packed(&self) -> bool { self.packed_offset.is_some() } + + pub fn jstype(&self) -> roto_runtime::Result { + let offset = self.jstype_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn deprecated(&self) -> crate::Result { - let offset = self.deprecated_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn jstype_or_default(&self) -> roto_runtime::Result { + self.jstype().or(Ok(0)) } - pub fn weak(&self) -> crate::Result { - let offset = self.weak_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_jstype(&self) -> bool { self.jstype_offset.is_some() } + + pub fn lazy(&self) -> roto_runtime::Result { + let offset = self.lazy_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn debug_redact(&self) -> crate::Result { - let offset = self.debug_redact_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn lazy_or_default(&self) -> roto_runtime::Result { + self.lazy().or(Ok(false)) } - pub fn retention(&self) -> crate::Result { - let offset = self.retention_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_lazy(&self) -> bool { self.lazy_offset.is_some() } + + pub fn unverified_lazy(&self) -> roto_runtime::Result { + let offset = self.unverified_lazy_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn targets(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn unverified_lazy_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn weak(&self) -> roto_runtime::Result { + let offset = self.weak_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn weak_or_default(&self) -> roto_runtime::Result { + self.weak().or(Ok(false)) + } + + pub fn has_weak(&self) -> bool { self.weak_offset.is_some() } + + pub fn debug_redact(&self) -> roto_runtime::Result { + let offset = self.debug_redact_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn debug_redact_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.retention_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn retention_or_default(&self) -> roto_runtime::Result { + self.retention().or(Ok(0)) + } + + pub fn has_retention(&self) -> bool { self.retention_offset.is_some() } + + pub fn targets(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn edition_defaults(&self) -> roto_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::Result<&'a [u8]> { - let offset = self.features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn features(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn feature_support(&self) -> crate::Result<&'a [u8]> { - let offset = self.feature_support_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn feature_support(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.feature_support_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn uninterpreted_option(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn feature_support_or_default(&self) -> roto_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) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FieldOptionsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, ctype_written: bool, packed_written: bool, jstype_written: bool, @@ -3273,7 +4179,7 @@ pub struct FieldOptionsBuilder<'b> { impl<'b> FieldOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FieldOptionsBuilder<'_> { FieldOptionsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), ctype_written: false, packed_written: false, jstype_written: false, @@ -3291,92 +4197,92 @@ impl<'b> FieldOptionsBuilder<'b> { } } - pub fn ctype(mut self, value: u64) -> crate::Result { + pub fn ctype(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(1, value)?; self.ctype_written = true; Ok(self) } - pub fn packed(mut self, value: u64) -> crate::Result { + pub fn packed(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(2, value)?; self.packed_written = true; Ok(self) } - pub fn jstype(mut self, value: u64) -> crate::Result { + pub fn jstype(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(6, value)?; self.jstype_written = true; Ok(self) } - pub fn lazy(mut self, value: u64) -> crate::Result { + pub fn lazy(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(5, value)?; self.lazy_written = true; Ok(self) } - pub fn unverified_lazy(mut self, value: u64) -> crate::Result { + pub fn unverified_lazy(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(15, value)?; self.unverified_lazy_written = true; Ok(self) } - pub fn deprecated(mut self, value: u64) -> crate::Result { + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(3, value)?; self.deprecated_written = true; Ok(self) } - pub fn weak(mut self, value: u64) -> crate::Result { + pub fn weak(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(10, value)?; self.weak_written = true; Ok(self) } - pub fn debug_redact(mut self, value: u64) -> crate::Result { + pub fn debug_redact(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(16, value)?; self.debug_redact_written = true; Ok(self) } - pub fn retention(mut self, value: u64) -> crate::Result { + pub fn retention(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(17, value)?; self.retention_written = true; Ok(self) } - pub fn targets(mut self, value: u64) -> crate::Result { + pub fn targets(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(19, value)?; self.targets_written = true; Ok(self) } - pub fn edition_defaults(mut self, value: &[u8]) -> crate::Result { + pub fn edition_defaults(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(20, value)?; self.edition_defaults_written = true; Ok(self) } - pub fn features(mut self, value: &[u8]) -> crate::Result { + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(21, value)?; self.features_written = true; Ok(self) } - pub fn feature_support(mut self, value: &[u8]) -> crate::Result { + pub fn feature_support(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(22, value)?; self.feature_support_written = true; Ok(self) } - pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } - pub fn with(mut self, msg: &FieldOptions<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &FieldOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.ctype_written, @@ -3402,11 +4308,35 @@ impl<'b> FieldOptionsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFieldOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFieldOptions { + type Reader<'a> = FieldOptions<'a>; + fn reader(&self) -> FieldOptions<'_> { + FieldOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFieldOptions { + fn decode(buf: bytes::Bytes) -> roto_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)] @@ -3499,14 +4429,14 @@ impl OptionTargetType { } pub struct EditionDefault<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, edition_offset: Option, value_offset: Option, } impl<'a> EditionDefault<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut edition_offset = None; let mut value_offset = None; for item in accessor.fields() { @@ -3522,26 +4452,38 @@ value_offset, }) } - pub fn edition(&self) -> crate::Result { - let offset = self.edition_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn edition(&self) -> roto_runtime::Result { + let offset = self.edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn value(&self) -> crate::Result<&'a str> { - let offset = self.value_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn edition_or_default(&self) -> roto_runtime::Result { + self.edition().or(Ok(0)) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_edition(&self) -> bool { self.edition_offset.is_some() } + + pub fn value(&self) -> roto_runtime::Result<&'a str> { + let offset = self.value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn value_or_default(&self) -> roto_runtime::Result<&'a str> { + self.value().or(Ok("")) + } + + pub fn has_value(&self) -> bool { self.value_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EditionDefaultBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, edition_written: bool, value_written: bool, } @@ -3549,26 +4491,26 @@ pub struct EditionDefaultBuilder<'b> { impl<'b> EditionDefaultBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EditionDefaultBuilder<'_> { EditionDefaultBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), edition_written: false, value_written: false, } } - pub fn edition(mut self, value: u64) -> crate::Result { + pub fn edition(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(3, value)?; self.edition_written = true; Ok(self) } - pub fn value(mut self, value: &str) -> crate::Result { + pub fn value(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(2, value)?; self.value_written = true; Ok(self) } - pub fn with(mut self, msg: &EditionDefault<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &EditionDefault<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 3 => self.edition_written, @@ -3582,13 +4524,37 @@ impl<'b> EditionDefaultBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedEditionDefault { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEditionDefault { + type Reader<'a> = EditionDefault<'a>; + fn reader(&self) -> EditionDefault<'_> { + EditionDefault::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEditionDefault { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEditionDefault { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct FeatureSupport<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, edition_introduced_offset: Option, edition_deprecated_offset: Option, deprecation_warning_offset: Option, @@ -3597,8 +4563,8 @@ pub struct FeatureSupport<'a> { } impl<'a> FeatureSupport<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut edition_introduced_offset = None; let mut edition_deprecated_offset = None; let mut deprecation_warning_offset = None; @@ -3623,44 +4589,74 @@ removal_error_offset, }) } - pub fn edition_introduced(&self) -> crate::Result { - let offset = self.edition_introduced_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn edition_introduced(&self) -> roto_runtime::Result { + let offset = self.edition_introduced_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn edition_deprecated(&self) -> crate::Result { - let offset = self.edition_deprecated_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn edition_introduced_or_default(&self) -> roto_runtime::Result { + self.edition_introduced().or(Ok(0)) } - pub fn deprecation_warning(&self) -> crate::Result<&'a str> { - let offset = self.deprecation_warning_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_edition_introduced(&self) -> bool { self.edition_introduced_offset.is_some() } + + pub fn edition_deprecated(&self) -> roto_runtime::Result { + let offset = self.edition_deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn edition_removed(&self) -> crate::Result { - let offset = self.edition_removed_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn edition_deprecated_or_default(&self) -> roto_runtime::Result { + self.edition_deprecated().or(Ok(0)) } - pub fn removal_error(&self) -> crate::Result<&'a str> { - let offset = self.removal_error_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_edition_deprecated(&self) -> bool { self.edition_deprecated_offset.is_some() } + + pub fn deprecation_warning(&self) -> roto_runtime::Result<&'a str> { + let offset = self.deprecation_warning_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn deprecation_warning_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.edition_removed_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn edition_removed_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.removal_error_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn removal_error_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FeatureSupportBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, edition_introduced_written: bool, edition_deprecated_written: bool, deprecation_warning_written: bool, @@ -3671,7 +4667,7 @@ pub struct FeatureSupportBuilder<'b> { impl<'b> FeatureSupportBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSupportBuilder<'_> { FeatureSupportBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), edition_introduced_written: false, edition_deprecated_written: false, deprecation_warning_written: false, @@ -3680,38 +4676,38 @@ impl<'b> FeatureSupportBuilder<'b> { } } - pub fn edition_introduced(mut self, value: u64) -> crate::Result { + pub fn edition_introduced(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(1, value)?; self.edition_introduced_written = true; Ok(self) } - pub fn edition_deprecated(mut self, value: u64) -> crate::Result { + pub fn edition_deprecated(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(2, value)?; self.edition_deprecated_written = true; Ok(self) } - pub fn deprecation_warning(mut self, value: &str) -> crate::Result { + pub fn deprecation_warning(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(3, value)?; self.deprecation_warning_written = true; Ok(self) } - pub fn edition_removed(mut self, value: u64) -> crate::Result { + pub fn edition_removed(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(4, value)?; self.edition_removed_written = true; Ok(self) } - pub fn removal_error(mut self, value: &str) -> crate::Result { + pub fn removal_error(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(5, value)?; self.removal_error_written = true; Ok(self) } - pub fn with(mut self, msg: &FeatureSupport<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &FeatureSupport<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.edition_introduced_written, @@ -3728,23 +4724,47 @@ impl<'b> FeatureSupportBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFeatureSupport { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFeatureSupport { + type Reader<'a> = FeatureSupport<'a>; + fn reader(&self) -> FeatureSupport<'_> { + FeatureSupport::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFeatureSupport { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFeatureSupport { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + } pub struct OneofOptions<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_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::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut features_offset = None; let mut uninterpreted_option_start = None; let mut uninterpreted_option_end = None; @@ -3764,27 +4784,33 @@ uninterpreted_option_start, uninterpreted_option_end, }) } - pub fn features(&self) -> crate::Result<&'a [u8]> { - let offset = self.features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn features(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn uninterpreted_option(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct OneofOptionsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, features_written: bool, uninterpreted_option_written: bool, } @@ -3792,26 +4818,26 @@ pub struct OneofOptionsBuilder<'b> { impl<'b> OneofOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> OneofOptionsBuilder<'_> { OneofOptionsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), features_written: false, uninterpreted_option_written: false, } } - pub fn features(mut self, value: &[u8]) -> crate::Result { + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(1, value)?; self.features_written = true; Ok(self) } - pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } - pub fn with(mut self, msg: &OneofOptions<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &OneofOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.features_written, @@ -3825,13 +4851,37 @@ impl<'b> OneofOptionsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedOneofOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedOneofOptions { + type Reader<'a> = OneofOptions<'a>; + fn reader(&self) -> OneofOptions<'_> { + OneofOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedOneofOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedOneofOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct EnumOptions<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, allow_alias_offset: Option, deprecated_offset: Option, deprecated_legacy_json_field_conflicts_offset: Option, @@ -3841,8 +4891,8 @@ pub struct EnumOptions<'a> { } impl<'a> EnumOptions<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut allow_alias_offset = None; let mut deprecated_offset = None; let mut deprecated_legacy_json_field_conflicts_offset = None; @@ -3871,45 +4921,69 @@ uninterpreted_option_start, uninterpreted_option_end, }) } - pub fn allow_alias(&self) -> crate::Result { - let offset = self.allow_alias_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn allow_alias(&self) -> roto_runtime::Result { + let offset = self.allow_alias_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn deprecated(&self) -> crate::Result { - let offset = self.deprecated_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn allow_alias_or_default(&self) -> roto_runtime::Result { + self.allow_alias().or(Ok(false)) } - pub fn deprecated_legacy_json_field_conflicts(&self) -> crate::Result { - let offset = self.deprecated_legacy_json_field_conflicts_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_allow_alias(&self) -> bool { self.allow_alias_offset.is_some() } + + pub fn deprecated(&self) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn features(&self) -> crate::Result<&'a [u8]> { - let offset = self.features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn deprecated_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_legacy_json_field_conflicts_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_legacy_json_field_conflicts_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn uninterpreted_option(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumOptionsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, allow_alias_written: bool, deprecated_written: bool, deprecated_legacy_json_field_conflicts_written: bool, @@ -3920,7 +4994,7 @@ pub struct EnumOptionsBuilder<'b> { impl<'b> EnumOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumOptionsBuilder<'_> { EnumOptionsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), allow_alias_written: false, deprecated_written: false, deprecated_legacy_json_field_conflicts_written: false, @@ -3929,38 +5003,38 @@ impl<'b> EnumOptionsBuilder<'b> { } } - pub fn allow_alias(mut self, value: u64) -> crate::Result { + pub fn allow_alias(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(2, value)?; self.allow_alias_written = true; Ok(self) } - pub fn deprecated(mut self, value: u64) -> crate::Result { + pub fn deprecated(mut self, value: u64) -> roto_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::Result { + pub fn deprecated_legacy_json_field_conflicts(mut self, value: u64) -> roto_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::Result { + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(7, value)?; self.features_written = true; Ok(self) } - pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } - pub fn with(mut self, msg: &EnumOptions<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &EnumOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 2 => self.allow_alias_written, @@ -3977,13 +5051,37 @@ impl<'b> EnumOptionsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedEnumOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumOptions { + type Reader<'a> = EnumOptions<'a>; + fn reader(&self) -> EnumOptions<'_> { + EnumOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEnumOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct EnumValueOptions<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, deprecated_offset: Option, features_offset: Option, debug_redact_offset: Option, @@ -3993,8 +5091,8 @@ pub struct EnumValueOptions<'a> { } impl<'a> EnumValueOptions<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut deprecated_offset = None; let mut features_offset = None; let mut debug_redact_offset = None; @@ -4023,45 +5121,69 @@ uninterpreted_option_start, uninterpreted_option_end, }) } - pub fn deprecated(&self) -> crate::Result { - let offset = self.deprecated_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn deprecated(&self) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn features(&self) -> crate::Result<&'a [u8]> { - let offset = self.features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn features(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn debug_redact(&self) -> crate::Result { - let offset = self.debug_redact_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) } - pub fn feature_support(&self) -> crate::Result<&'a [u8]> { - let offset = self.feature_support_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn debug_redact(&self) -> roto_runtime::Result { + let offset = self.debug_redact_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn debug_redact_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.feature_support_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn uninterpreted_option(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn feature_support_or_default(&self) -> roto_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) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct EnumValueOptionsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, deprecated_written: bool, features_written: bool, debug_redact_written: bool, @@ -4072,7 +5194,7 @@ pub struct EnumValueOptionsBuilder<'b> { impl<'b> EnumValueOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumValueOptionsBuilder<'_> { EnumValueOptionsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), deprecated_written: false, features_written: false, debug_redact_written: false, @@ -4081,38 +5203,38 @@ impl<'b> EnumValueOptionsBuilder<'b> { } } - pub fn deprecated(mut self, value: u64) -> crate::Result { + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(1, value)?; self.deprecated_written = true; Ok(self) } - pub fn features(mut self, value: &[u8]) -> crate::Result { + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(2, value)?; self.features_written = true; Ok(self) } - pub fn debug_redact(mut self, value: u64) -> crate::Result { + pub fn debug_redact(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(3, value)?; self.debug_redact_written = true; Ok(self) } - pub fn feature_support(mut self, value: &[u8]) -> crate::Result { + pub fn feature_support(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(4, value)?; self.feature_support_written = true; Ok(self) } - pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } - pub fn with(mut self, msg: &EnumValueOptions<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &EnumValueOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.deprecated_written, @@ -4129,13 +5251,37 @@ impl<'b> EnumValueOptionsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedEnumValueOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumValueOptions { + type Reader<'a> = EnumValueOptions<'a>; + fn reader(&self) -> EnumValueOptions<'_> { + EnumValueOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumValueOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEnumValueOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct ServiceOptions<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, features_offset: Option, deprecated_offset: Option, uninterpreted_option_start: Option, @@ -4143,8 +5289,8 @@ pub struct ServiceOptions<'a> { } impl<'a> ServiceOptions<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut features_offset = None; let mut deprecated_offset = None; let mut uninterpreted_option_start = None; @@ -4167,33 +5313,45 @@ uninterpreted_option_start, uninterpreted_option_end, }) } - pub fn features(&self) -> crate::Result<&'a [u8]> { - let offset = self.features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn features(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn deprecated(&self) -> crate::Result { - let offset = self.deprecated_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) } - pub fn uninterpreted_option(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn deprecated(&self) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ServiceOptionsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, features_written: bool, deprecated_written: bool, uninterpreted_option_written: bool, @@ -4202,33 +5360,33 @@ pub struct ServiceOptionsBuilder<'b> { impl<'b> ServiceOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ServiceOptionsBuilder<'_> { ServiceOptionsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), features_written: false, deprecated_written: false, uninterpreted_option_written: false, } } - pub fn features(mut self, value: &[u8]) -> crate::Result { + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(34, value)?; self.features_written = true; Ok(self) } - pub fn deprecated(mut self, value: u64) -> crate::Result { + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(33, value)?; self.deprecated_written = true; Ok(self) } - pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } - pub fn with(mut self, msg: &ServiceOptions<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &ServiceOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 34 => self.features_written, @@ -4243,13 +5401,37 @@ impl<'b> ServiceOptionsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedServiceOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedServiceOptions { + type Reader<'a> = ServiceOptions<'a>; + fn reader(&self) -> ServiceOptions<'_> { + ServiceOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedServiceOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedServiceOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct MethodOptions<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, deprecated_offset: Option, idempotency_level_offset: Option, features_offset: Option, @@ -4258,8 +5440,8 @@ pub struct MethodOptions<'a> { } impl<'a> MethodOptions<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut deprecated_offset = None; let mut idempotency_level_offset = None; let mut features_offset = None; @@ -4285,39 +5467,57 @@ uninterpreted_option_start, uninterpreted_option_end, }) } - pub fn deprecated(&self) -> crate::Result { - let offset = self.deprecated_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn deprecated(&self) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn idempotency_level(&self) -> crate::Result { - let offset = self.idempotency_level_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) } - pub fn features(&self) -> crate::Result<&'a [u8]> { - let offset = self.features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn idempotency_level(&self) -> roto_runtime::Result { + let offset = self.idempotency_level_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn idempotency_level_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn uninterpreted_option(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct MethodOptionsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, deprecated_written: bool, idempotency_level_written: bool, features_written: bool, @@ -4327,7 +5527,7 @@ pub struct MethodOptionsBuilder<'b> { impl<'b> MethodOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> MethodOptionsBuilder<'_> { MethodOptionsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), deprecated_written: false, idempotency_level_written: false, features_written: false, @@ -4335,32 +5535,32 @@ impl<'b> MethodOptionsBuilder<'b> { } } - pub fn deprecated(mut self, value: u64) -> crate::Result { + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(33, value)?; self.deprecated_written = true; Ok(self) } - pub fn idempotency_level(mut self, value: u64) -> crate::Result { + pub fn idempotency_level(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(34, value)?; self.idempotency_level_written = true; Ok(self) } - pub fn features(mut self, value: &[u8]) -> crate::Result { + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(35, value)?; self.features_written = true; Ok(self) } - pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(999, value)?; self.uninterpreted_option_written = true; Ok(self) } - pub fn with(mut self, msg: &MethodOptions<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &MethodOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 33 => self.deprecated_written, @@ -4376,11 +5576,35 @@ impl<'b> MethodOptionsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedMethodOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedMethodOptions { + type Reader<'a> = MethodOptions<'a>; + fn reader(&self) -> MethodOptions<'_> { + MethodOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedMethodOptions { + fn decode(buf: bytes::Bytes) -> roto_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)] @@ -4404,7 +5628,7 @@ impl IdempotencyLevel { } pub struct UninterpretedOption<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_start: Option, name_end: Option, identifier_value_offset: Option, @@ -4416,8 +5640,8 @@ pub struct UninterpretedOption<'a> { } impl<'a> UninterpretedOption<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_start = None; let mut name_end = None; let mut identifier_value_offset = None; @@ -4452,57 +5676,93 @@ aggregate_value_offset, }) } - pub fn name(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn name(&self) -> roto_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::Result<&'a str> { - let offset = self.identifier_value_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn identifier_value(&self) -> roto_runtime::Result<&'a str> { + let offset = self.identifier_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn positive_int_value(&self) -> crate::Result { - let offset = self.positive_int_value_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn identifier_value_or_default(&self) -> roto_runtime::Result<&'a str> { + self.identifier_value().or(Ok("")) } - pub fn negative_int_value(&self) -> crate::Result { - let offset = self.negative_int_value_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_identifier_value(&self) -> bool { self.identifier_value_offset.is_some() } + + pub fn positive_int_value(&self) -> roto_runtime::Result { + let offset = self.positive_int_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn double_value(&self) -> crate::Result { - let offset = self.double_value_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - Ok(f64::from_le_bytes(bytes.try_into().map_err(|_| crate::RotoError::WireFormatViolation)?)) + pub fn positive_int_value_or_default(&self) -> roto_runtime::Result { + self.positive_int_value().or(Ok(0)) } - pub fn string_value(&self) -> crate::Result<&'a [u8]> { - let offset = self.string_value_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_positive_int_value(&self) -> bool { self.positive_int_value_offset.is_some() } + + pub fn negative_int_value(&self) -> roto_runtime::Result { + let offset = self.negative_int_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn negative_int_value_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.double_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(f64::from_le_bytes(bytes.try_into().map_err(|_| roto_runtime::RotoError::WireFormatViolation)?)) + } + + pub fn double_value_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.string_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn aggregate_value(&self) -> crate::Result<&'a str> { - let offset = self.aggregate_value_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn string_value_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.string_value().or(Ok(&[])) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_string_value(&self) -> bool { self.string_value_offset.is_some() } + + pub fn aggregate_value(&self) -> roto_runtime::Result<&'a str> { + let offset = self.aggregate_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn aggregate_value_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct UninterpretedOptionBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_written: bool, identifier_value_written: bool, positive_int_value_written: bool, @@ -4515,7 +5775,7 @@ pub struct UninterpretedOptionBuilder<'b> { impl<'b> UninterpretedOptionBuilder<'b> { pub fn builder(buf: &mut [u8]) -> UninterpretedOptionBuilder<'_> { UninterpretedOptionBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_written: false, identifier_value_written: false, positive_int_value_written: false, @@ -4526,50 +5786,50 @@ impl<'b> UninterpretedOptionBuilder<'b> { } } - pub fn name(mut self, value: &[u8]) -> crate::Result { + pub fn name(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(2, value)?; self.name_written = true; Ok(self) } - pub fn identifier_value(mut self, value: &str) -> crate::Result { + pub fn identifier_value(mut self, value: &str) -> roto_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::Result { + pub fn positive_int_value(mut self, value: u64) -> roto_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::Result { + pub fn negative_int_value(mut self, value: u64) -> roto_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::Result { + pub fn double_value(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(6, value)?; self.double_value_written = true; Ok(self) } - pub fn string_value(mut self, value: &[u8]) -> crate::Result { + pub fn string_value(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(7, value)?; self.string_value_written = true; Ok(self) } - pub fn aggregate_value(mut self, value: &str) -> crate::Result { + pub fn aggregate_value(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(8, value)?; self.aggregate_value_written = true; Ok(self) } - pub fn with(mut self, msg: &UninterpretedOption<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &UninterpretedOption<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 2 => self.name_written, @@ -4588,21 +5848,45 @@ impl<'b> UninterpretedOptionBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedUninterpretedOption { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedUninterpretedOption { + type Reader<'a> = UninterpretedOption<'a>; + fn reader(&self) -> UninterpretedOption<'_> { + UninterpretedOption::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedUninterpretedOption { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedUninterpretedOption { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub mod uninterpreted_option { pub struct NamePart<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, name_part_offset: Option, is_extension_offset: Option, } impl<'a> NamePart<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut name_part_offset = None; let mut is_extension_offset = None; for item in accessor.fields() { @@ -4618,26 +5902,38 @@ is_extension_offset, }) } - pub fn name_part(&self) -> crate::Result<&'a str> { - let offset = self.name_part_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn name_part(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_part_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn is_extension(&self) -> crate::Result { - let offset = self.is_extension_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn name_part_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name_part().or(Ok("")) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_name_part(&self) -> bool { self.name_part_offset.is_some() } + + pub fn is_extension(&self) -> roto_runtime::Result { + let offset = self.is_extension_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn is_extension_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct NamePartBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, name_part_written: bool, is_extension_written: bool, } @@ -4645,26 +5941,26 @@ pub struct NamePartBuilder<'b> { impl<'b> NamePartBuilder<'b> { pub fn builder(buf: &mut [u8]) -> NamePartBuilder<'_> { NamePartBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), name_part_written: false, is_extension_written: false, } } - pub fn name_part(mut self, value: &str) -> crate::Result { + pub fn name_part(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(1, value)?; self.name_part_written = true; Ok(self) } - pub fn is_extension(mut self, value: u64) -> crate::Result { + pub fn is_extension(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(2, value)?; self.is_extension_written = true; Ok(self) } - pub fn with(mut self, msg: &NamePart<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &NamePart<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_part_written, @@ -4678,15 +5974,39 @@ impl<'b> NamePartBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedNamePart { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedNamePart { + type Reader<'a> = NamePart<'a>; + fn reader(&self) -> NamePart<'_> { + NamePart::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedNamePart { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedNamePart { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + } pub struct FeatureSet<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, field_presence_offset: Option, enum_type_offset: Option, repeated_field_encoding_offset: Option, @@ -4699,8 +6019,8 @@ pub struct FeatureSet<'a> { } impl<'a> FeatureSet<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut field_presence_offset = None; let mut enum_type_offset = None; let mut repeated_field_encoding_offset = None; @@ -4737,68 +6057,122 @@ enforce_proto_limits_offset, }) } - pub fn field_presence(&self) -> crate::Result { - let offset = self.field_presence_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn field_presence(&self) -> roto_runtime::Result { + let offset = self.field_presence_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn enum_type(&self) -> crate::Result { - let offset = self.enum_type_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn field_presence_or_default(&self) -> roto_runtime::Result { + self.field_presence().or(Ok(0)) } - pub fn repeated_field_encoding(&self) -> crate::Result { - let offset = self.repeated_field_encoding_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_field_presence(&self) -> bool { self.field_presence_offset.is_some() } + + pub fn enum_type(&self) -> roto_runtime::Result { + let offset = self.enum_type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn utf8_validation(&self) -> crate::Result { - let offset = self.utf8_validation_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn enum_type_or_default(&self) -> roto_runtime::Result { + self.enum_type().or(Ok(0)) } - pub fn message_encoding(&self) -> crate::Result { - let offset = self.message_encoding_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_enum_type(&self) -> bool { self.enum_type_offset.is_some() } + + pub fn repeated_field_encoding(&self) -> roto_runtime::Result { + let offset = self.repeated_field_encoding_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn json_format(&self) -> crate::Result { - let offset = self.json_format_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn repeated_field_encoding_or_default(&self) -> roto_runtime::Result { + self.repeated_field_encoding().or(Ok(0)) } - pub fn enforce_naming_style(&self) -> crate::Result { - let offset = self.enforce_naming_style_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_repeated_field_encoding(&self) -> bool { self.repeated_field_encoding_offset.is_some() } + + pub fn utf8_validation(&self) -> roto_runtime::Result { + let offset = self.utf8_validation_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn default_symbol_visibility(&self) -> crate::Result { - let offset = self.default_symbol_visibility_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn utf8_validation_or_default(&self) -> roto_runtime::Result { + self.utf8_validation().or(Ok(0)) } - pub fn enforce_proto_limits(&self) -> crate::Result { - let offset = self.enforce_proto_limits_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_utf8_validation(&self) -> bool { self.utf8_validation_offset.is_some() } + + pub fn message_encoding(&self) -> roto_runtime::Result { + let offset = self.message_encoding_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn message_encoding_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.json_format_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn json_format_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.enforce_naming_style_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn enforce_naming_style_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.default_symbol_visibility_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn default_symbol_visibility_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.enforce_proto_limits_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn enforce_proto_limits_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FeatureSetBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, field_presence_written: bool, enum_type_written: bool, repeated_field_encoding_written: bool, @@ -4813,7 +6187,7 @@ pub struct FeatureSetBuilder<'b> { impl<'b> FeatureSetBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSetBuilder<'_> { FeatureSetBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), field_presence_written: false, enum_type_written: false, repeated_field_encoding_written: false, @@ -4826,62 +6200,62 @@ impl<'b> FeatureSetBuilder<'b> { } } - pub fn field_presence(mut self, value: u64) -> crate::Result { + pub fn field_presence(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(1, value)?; self.field_presence_written = true; Ok(self) } - pub fn enum_type(mut self, value: u64) -> crate::Result { + pub fn enum_type(mut self, value: u64) -> roto_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::Result { + pub fn repeated_field_encoding(mut self, value: u64) -> roto_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::Result { + pub fn utf8_validation(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(4, value)?; self.utf8_validation_written = true; Ok(self) } - pub fn message_encoding(mut self, value: u64) -> crate::Result { + pub fn message_encoding(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(5, value)?; self.message_encoding_written = true; Ok(self) } - pub fn json_format(mut self, value: u64) -> crate::Result { + pub fn json_format(mut self, value: u64) -> roto_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::Result { + pub fn enforce_naming_style(mut self, value: u64) -> roto_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::Result { + pub fn default_symbol_visibility(mut self, value: u64) -> roto_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::Result { + pub fn enforce_proto_limits(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(9, value)?; self.enforce_proto_limits_written = true; Ok(self) } - pub fn with(mut self, msg: &FeatureSet<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &FeatureSet<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.field_presence_written, @@ -4902,11 +6276,35 @@ impl<'b> FeatureSetBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFeatureSet { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFeatureSet { + type Reader<'a> = FeatureSet<'a>; + fn reader(&self) -> FeatureSet<'_> { + FeatureSet::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFeatureSet { + fn decode(buf: bytes::Bytes) -> roto_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)] @@ -5046,36 +6444,40 @@ impl EnforceNamingStyle { } pub struct VisibilityFeature<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, } impl<'a> VisibilityFeature<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; + for item in accessor.fields() { + let (offset, tag, _) = item?; + } + Ok(Self { accessor, }) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct VisibilityFeatureBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, } impl<'b> VisibilityFeatureBuilder<'b> { pub fn builder(buf: &mut [u8]) -> VisibilityFeatureBuilder<'_> { VisibilityFeatureBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), } } - pub fn with(mut self, msg: &VisibilityFeature<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &VisibilityFeature<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { _ => false, @@ -5087,11 +6489,35 @@ impl<'b> VisibilityFeatureBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedVisibilityFeature { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedVisibilityFeature { + type Reader<'a> = VisibilityFeature<'a>; + fn reader(&self) -> VisibilityFeature<'_> { + VisibilityFeature::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedVisibilityFeature { + fn decode(buf: bytes::Bytes) -> roto_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)] @@ -5119,36 +6545,40 @@ impl DefaultSymbolVisibility { } pub struct ProtoLimitsFeature<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, } impl<'a> ProtoLimitsFeature<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; + for item in accessor.fields() { + let (offset, tag, _) = item?; + } + Ok(Self { accessor, }) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct ProtoLimitsFeatureBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, } impl<'b> ProtoLimitsFeatureBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ProtoLimitsFeatureBuilder<'_> { ProtoLimitsFeatureBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), } } - pub fn with(mut self, msg: &ProtoLimitsFeature<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &ProtoLimitsFeature<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { _ => false, @@ -5160,11 +6590,35 @@ impl<'b> ProtoLimitsFeatureBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedProtoLimitsFeature { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedProtoLimitsFeature { + type Reader<'a> = ProtoLimitsFeature<'a>; + fn reader(&self) -> ProtoLimitsFeature<'_> { + ProtoLimitsFeature::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedProtoLimitsFeature { + fn decode(buf: bytes::Bytes) -> roto_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)] @@ -5190,7 +6644,7 @@ impl EnforceProtoLimits { } pub struct FeatureSetDefaults<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, defaults_start: Option, defaults_end: Option, minimum_edition_offset: Option, @@ -5198,8 +6652,8 @@ pub struct FeatureSetDefaults<'a> { } impl<'a> FeatureSetDefaults<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut defaults_start = None; let mut defaults_end = None; let mut minimum_edition_offset = None; @@ -5222,33 +6676,45 @@ maximum_edition_offset, }) } - pub fn defaults(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn defaults(&self) -> roto_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::Result { - let offset = self.minimum_edition_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn minimum_edition(&self) -> roto_runtime::Result { + let offset = self.minimum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn maximum_edition(&self) -> crate::Result { - let offset = self.maximum_edition_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn minimum_edition_or_default(&self) -> roto_runtime::Result { + self.minimum_edition().or(Ok(0)) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_minimum_edition(&self) -> bool { self.minimum_edition_offset.is_some() } + + pub fn maximum_edition(&self) -> roto_runtime::Result { + let offset = self.maximum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn maximum_edition_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FeatureSetDefaultsBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, defaults_written: bool, minimum_edition_written: bool, maximum_edition_written: bool, @@ -5257,33 +6723,33 @@ pub struct FeatureSetDefaultsBuilder<'b> { impl<'b> FeatureSetDefaultsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSetDefaultsBuilder<'_> { FeatureSetDefaultsBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), defaults_written: false, minimum_edition_written: false, maximum_edition_written: false, } } - pub fn defaults(mut self, value: &[u8]) -> crate::Result { + pub fn defaults(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(1, value)?; self.defaults_written = true; Ok(self) } - pub fn minimum_edition(mut self, value: u64) -> crate::Result { + pub fn minimum_edition(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(4, value)?; self.minimum_edition_written = true; Ok(self) } - pub fn maximum_edition(mut self, value: u64) -> crate::Result { + pub fn maximum_edition(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(5, value)?; self.maximum_edition_written = true; Ok(self) } - pub fn with(mut self, msg: &FeatureSetDefaults<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &FeatureSetDefaults<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.defaults_written, @@ -5298,22 +6764,46 @@ impl<'b> FeatureSetDefaultsBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFeatureSetDefaults { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFeatureSetDefaults { + type Reader<'a> = FeatureSetDefaults<'a>; + fn reader(&self) -> FeatureSetDefaults<'_> { + FeatureSetDefaults::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFeatureSetDefaults { + fn decode(buf: bytes::Bytes) -> roto_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::ProtoAccessor<'a>, + accessor: roto_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::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut edition_offset = None; let mut overridable_features_offset = None; let mut fixed_features_offset = None; @@ -5332,32 +6822,50 @@ fixed_features_offset, }) } - pub fn edition(&self) -> crate::Result { - let offset = self.edition_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn edition(&self) -> roto_runtime::Result { + let offset = self.edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn overridable_features(&self) -> crate::Result<&'a [u8]> { - let offset = self.overridable_features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn edition_or_default(&self) -> roto_runtime::Result { + self.edition().or(Ok(0)) + } + + pub fn has_edition(&self) -> bool { self.edition_offset.is_some() } + + pub fn overridable_features(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.overridable_features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn fixed_features(&self) -> crate::Result<&'a [u8]> { - let offset = self.fixed_features_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn overridable_features_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.fixed_features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn fixed_features_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct FeatureSetEditionDefaultBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, edition_written: bool, overridable_features_written: bool, fixed_features_written: bool, @@ -5366,33 +6874,33 @@ pub struct FeatureSetEditionDefaultBuilder<'b> { impl<'b> FeatureSetEditionDefaultBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSetEditionDefaultBuilder<'_> { FeatureSetEditionDefaultBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), edition_written: false, overridable_features_written: false, fixed_features_written: false, } } - pub fn edition(mut self, value: u64) -> crate::Result { + pub fn edition(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(3, value)?; self.edition_written = true; Ok(self) } - pub fn overridable_features(mut self, value: &[u8]) -> crate::Result { + pub fn overridable_features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(4, value)?; self.overridable_features_written = true; Ok(self) } - pub fn fixed_features(mut self, value: &[u8]) -> crate::Result { + pub fn fixed_features(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(5, value)?; self.fixed_features_written = true; Ok(self) } - pub fn with(mut self, msg: &FeatureSetEditionDefault<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &FeatureSetEditionDefault<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 3 => self.edition_written, @@ -5407,22 +6915,46 @@ impl<'b> FeatureSetEditionDefaultBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedFeatureSetEditionDefault { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFeatureSetEditionDefault { + type Reader<'a> = FeatureSetEditionDefault<'a>; + fn reader(&self) -> FeatureSetEditionDefault<'_> { + FeatureSetEditionDefault::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFeatureSetEditionDefault { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFeatureSetEditionDefault { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + } pub struct SourceCodeInfo<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, location_start: Option, location_end: Option, } impl<'a> SourceCodeInfo<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut location_start = None; let mut location_end = None; for item in accessor.fields() { @@ -5439,40 +6971,40 @@ location_start, location_end, }) } - pub fn location(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn location(&self) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct SourceCodeInfoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, location_written: bool, } impl<'b> SourceCodeInfoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> SourceCodeInfoBuilder<'_> { SourceCodeInfoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), location_written: false, } } - pub fn location(mut self, value: &[u8]) -> crate::Result { + pub fn location(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(1, value)?; self.location_written = true; Ok(self) } - pub fn with(mut self, msg: &SourceCodeInfo<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &SourceCodeInfo<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.location_written, @@ -5485,14 +7017,38 @@ impl<'b> SourceCodeInfoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedSourceCodeInfo { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedSourceCodeInfo { + type Reader<'a> = SourceCodeInfo<'a>; + fn reader(&self) -> SourceCodeInfo<'_> { + SourceCodeInfo::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedSourceCodeInfo { + fn decode(buf: bytes::Bytes) -> roto_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::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, path_start: Option, path_end: Option, span_start: Option, @@ -5504,8 +7060,8 @@ pub struct Location<'a> { } impl<'a> Location<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut path_start = None; let mut path_end = None; let mut span_start = None; @@ -5542,47 +7098,59 @@ leading_detached_comments_start, leading_detached_comments_end, }) } - pub fn path(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn path(&self) -> roto_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::RepeatedFieldIterator<'a> { + pub fn span(&self) -> roto_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::Result<&'a str> { - let offset = self.leading_comments_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn leading_comments(&self) -> roto_runtime::Result<&'a str> { + let offset = self.leading_comments_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn trailing_comments(&self) -> crate::Result<&'a str> { - let offset = self.trailing_comments_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn leading_comments_or_default(&self) -> roto_runtime::Result<&'a str> { + self.leading_comments().or(Ok("")) } - pub fn leading_detached_comments(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn has_leading_comments(&self) -> bool { self.leading_comments_offset.is_some() } + + pub fn trailing_comments(&self) -> roto_runtime::Result<&'a str> { + let offset = self.trailing_comments_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn trailing_comments_or_default(&self) -> roto_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) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct LocationBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, path_written: bool, span_written: bool, leading_comments_written: bool, @@ -5593,7 +7161,7 @@ pub struct LocationBuilder<'b> { impl<'b> LocationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> LocationBuilder<'_> { LocationBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), path_written: false, span_written: false, leading_comments_written: false, @@ -5602,38 +7170,38 @@ impl<'b> LocationBuilder<'b> { } } - pub fn path(mut self, value: i32) -> crate::Result { + pub fn path(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(1, value)?; self.path_written = true; Ok(self) } - pub fn span(mut self, value: i32) -> crate::Result { + pub fn span(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(2, value)?; self.span_written = true; Ok(self) } - pub fn leading_comments(mut self, value: &str) -> crate::Result { + pub fn leading_comments(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(3, value)?; self.leading_comments_written = true; Ok(self) } - pub fn trailing_comments(mut self, value: &str) -> crate::Result { + pub fn trailing_comments(mut self, value: &str) -> roto_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::Result { + pub fn leading_detached_comments(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(6, value)?; self.leading_detached_comments_written = true; Ok(self) } - pub fn with(mut self, msg: &Location<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &Location<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.path_written, @@ -5650,22 +7218,46 @@ impl<'b> LocationBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedLocation { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedLocation { + type Reader<'a> = Location<'a>; + fn reader(&self) -> Location<'_> { + Location::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedLocation { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedLocation { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + } pub struct GeneratedCodeInfo<'a> { - accessor: crate::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, annotation_start: Option, annotation_end: Option, } impl<'a> GeneratedCodeInfo<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut annotation_start = None; let mut annotation_end = None; for item in accessor.fields() { @@ -5682,40 +7274,40 @@ annotation_start, annotation_end, }) } - pub fn annotation(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn annotation(&self) -> roto_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::RawFieldIterator<'a> { + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct GeneratedCodeInfoBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, annotation_written: bool, } impl<'b> GeneratedCodeInfoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> GeneratedCodeInfoBuilder<'_> { GeneratedCodeInfoBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), annotation_written: false, } } - pub fn annotation(mut self, value: &[u8]) -> crate::Result { + pub fn annotation(mut self, value: &[u8]) -> roto_runtime::Result { self.builder.write_bytes(1, value)?; self.annotation_written = true; Ok(self) } - pub fn with(mut self, msg: &GeneratedCodeInfo<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &GeneratedCodeInfo<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.annotation_written, @@ -5728,14 +7320,38 @@ impl<'b> GeneratedCodeInfoBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedGeneratedCodeInfo { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedGeneratedCodeInfo { + type Reader<'a> = GeneratedCodeInfo<'a>; + fn reader(&self) -> GeneratedCodeInfo<'_> { + GeneratedCodeInfo::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedGeneratedCodeInfo { + fn decode(buf: bytes::Bytes) -> roto_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::ProtoAccessor<'a>, + accessor: roto_runtime::ProtoAccessor<'a>, path_start: Option, path_end: Option, source_file_offset: Option, @@ -5745,8 +7361,8 @@ pub struct Annotation<'a> { } impl<'a> Annotation<'a> { - pub fn new(data: &'a [u8]) -> crate::Result { - let accessor = crate::ProtoAccessor::new(data)?; + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; let mut path_start = None; let mut path_end = None; let mut source_file_offset = None; @@ -5775,45 +7391,69 @@ semantic_offset, }) } - pub fn path(&self) -> crate::RepeatedFieldIterator<'a> { + pub fn path(&self) -> roto_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::Result<&'a str> { - let offset = self.source_file_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn source_file(&self) -> roto_runtime::Result<&'a str> { + let offset = self.source_file_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn begin(&self) -> crate::Result { - let offset = self.begin_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn source_file_or_default(&self) -> roto_runtime::Result<&'a str> { + self.source_file().or(Ok("")) } - pub fn end(&self) -> crate::Result { - let offset = self.end_offset.ok_or(crate::RotoError::FieldNotFound)?; + pub fn has_source_file(&self) -> bool { self.source_file_offset.is_some() } + + pub fn begin(&self) -> roto_runtime::Result { + let offset = self.begin_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn semantic(&self) -> crate::Result { - let offset = self.semantic_offset.ok_or(crate::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) + pub fn begin_or_default(&self) -> roto_runtime::Result { + self.begin().or(Ok(0)) } - pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + pub fn has_begin(&self) -> bool { self.begin_offset.is_some() } + + pub fn end(&self) -> roto_runtime::Result { + let offset = self.end_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } + + pub fn has_end(&self) -> bool { self.end_offset.is_some() } + + pub fn semantic(&self) -> roto_runtime::Result { + let offset = self.semantic_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn semantic_or_default(&self) -> roto_runtime::Result { + self.semantic().or(Ok(0)) + } + + pub fn has_semantic(&self) -> bool { self.semantic_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } } pub struct AnnotationBuilder<'b> { - builder: crate::ProtoBuilder<'b>, + builder: roto_runtime::ProtoBuilder<'b>, path_written: bool, source_file_written: bool, begin_written: bool, @@ -5824,7 +7464,7 @@ pub struct AnnotationBuilder<'b> { impl<'b> AnnotationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> AnnotationBuilder<'_> { AnnotationBuilder { - builder: crate::ProtoBuilder::new(buf), + builder: roto_runtime::ProtoBuilder::new(buf), path_written: false, source_file_written: false, begin_written: false, @@ -5833,38 +7473,38 @@ impl<'b> AnnotationBuilder<'b> { } } - pub fn path(mut self, value: i32) -> crate::Result { + pub fn path(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(1, value)?; self.path_written = true; Ok(self) } - pub fn source_file(mut self, value: &str) -> crate::Result { + pub fn source_file(mut self, value: &str) -> roto_runtime::Result { self.builder.write_string(2, value)?; self.source_file_written = true; Ok(self) } - pub fn begin(mut self, value: i32) -> crate::Result { + pub fn begin(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(3, value)?; self.begin_written = true; Ok(self) } - pub fn end(mut self, value: i32) -> crate::Result { + pub fn end(mut self, value: i32) -> roto_runtime::Result { self.builder.write_int32(4, value)?; self.end_written = true; Ok(self) } - pub fn semantic(mut self, value: u64) -> crate::Result { + pub fn semantic(mut self, value: u64) -> roto_runtime::Result { self.builder.write_varint(5, value)?; self.semantic_written = true; Ok(self) } - pub fn with(mut self, msg: &Annotation<'_>) -> crate::Result { - for item in msg.raw_fields() { + pub fn with(mut self, msg: &Annotation<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.path_written, @@ -5881,11 +7521,35 @@ impl<'b> AnnotationBuilder<'b> { Ok(self) } - pub fn finish(self) -> crate::Result<&'b mut [u8]> { + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { self.builder.finish() } } +#[cfg(feature = "alloc")] +pub struct OwnedAnnotation { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedAnnotation { + type Reader<'a> = Annotation<'a>; + fn reader(&self) -> Annotation<'_> { + Annotation::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedAnnotation { + fn decode(buf: bytes::Bytes) -> roto_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)] @@ -5910,3 +7574,5 @@ impl Semantic { } + + diff --git a/benches/src/hackers.rs b/benches/src/hackers.rs index e395e34..3507904 100644 --- a/benches/src/hackers.rs +++ b/benches/src/hackers.rs @@ -1,10 +1,9 @@ // @generated by protoc-gen-roto — do not edit -#![allow(unused_imports)] - -use roto_runtime::{ - ProtoAccessor, ProtoBuilder, RepeatedFieldIterator, Result, RotoError, read_varint, -}; -use std::str; +#[allow(unused_imports)] +use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator, RotoMessage}; +use core::str; +#[cfg(feature = "alloc")] +use bytes::{Bytes, BytesMut, Buf, BufMut}; pub struct Tool<'a> { accessor: roto_runtime::ProtoAccessor<'a>, @@ -25,80 +24,87 @@ impl<'a> Tool<'a> { let mut exploit_count_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 { - version_offset = Some(offset); - } - if tag.field_number == 3 { - payload_offset = Some(offset); - } - if tag.field_number == 4 { - is_active_offset = Some(offset); - } - if tag.field_number == 5 { - exploit_count_offset = Some(offset); - } + if tag.field_number == 1 { name_offset = Some(offset); } + if tag.field_number == 2 { version_offset = Some(offset); } + if tag.field_number == 3 { payload_offset = Some(offset); } + if tag.field_number == 4 { is_active_offset = Some(offset); } + if tag.field_number == 5 { exploit_count_offset = Some(offset); } } Ok(Self { accessor, - name_offset, - version_offset, - payload_offset, - is_active_offset, - exploit_count_offset, +name_offset, +version_offset, +payload_offset, +is_active_offset, +exploit_count_offset, }) } pub fn name(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .name_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + pub fn version(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .version_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.version_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn version_or_default(&self) -> roto_runtime::Result<&'a str> { + self.version().or(Ok("")) + } + + pub fn has_version(&self) -> bool { self.version_offset.is_some() } + pub fn payload(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .payload_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.payload_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn is_active(&self) -> roto_runtime::Result { - let offset = self - .is_active_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v != 0) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + pub fn payload_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.payload().or(Ok(&[])) } - pub fn exploit_count(&self) -> roto_runtime::Result { - let offset = self - .exploit_count_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + pub fn has_payload(&self) -> bool { self.payload_offset.is_some() } + + pub fn is_active(&self) -> roto_runtime::Result { + let offset = self.is_active_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn is_active_or_default(&self) -> roto_runtime::Result { + self.is_active().or(Ok(false)) + } + + pub fn has_is_active(&self) -> bool { self.is_active_offset.is_some() } + + pub fn exploit_count(&self) -> roto_runtime::Result { + let offset = self.exploit_count_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn exploit_count_or_default(&self) -> roto_runtime::Result { + self.exploit_count().or(Ok(0)) + } + + pub fn has_exploit_count(&self) -> bool { self.exploit_count_offset.is_some() } + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct ToolBuilder<'b> { @@ -153,7 +159,7 @@ impl<'b> ToolBuilder<'b> { } pub fn with(mut self, msg: &Tool<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -175,6 +181,30 @@ impl<'b> ToolBuilder<'b> { } } +#[cfg(feature = "alloc")] +pub struct OwnedTool { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedTool { + type Reader<'a> = Tool<'a>; + fn reader(&self) -> Tool<'_> { + Tool::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedTool { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedTool { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct Connection<'a> { accessor: roto_runtime::ProtoAccessor<'a>, host_offset: Option, @@ -194,82 +224,87 @@ impl<'a> Connection<'a> { let mut session_key_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; - if tag.field_number == 1 { - host_offset = Some(offset); - } - if tag.field_number == 2 { - port_offset = Some(offset); - } - if tag.field_number == 3 { - encrypted_offset = Some(offset); - } - if tag.field_number == 4 { - bandwidth_bps_offset = Some(offset); - } - if tag.field_number == 5 { - session_key_offset = Some(offset); - } + if tag.field_number == 1 { host_offset = Some(offset); } + if tag.field_number == 2 { port_offset = Some(offset); } + if tag.field_number == 3 { encrypted_offset = Some(offset); } + if tag.field_number == 4 { bandwidth_bps_offset = Some(offset); } + if tag.field_number == 5 { session_key_offset = Some(offset); } } Ok(Self { accessor, - host_offset, - port_offset, - encrypted_offset, - bandwidth_bps_offset, - session_key_offset, +host_offset, +port_offset, +encrypted_offset, +bandwidth_bps_offset, +session_key_offset, }) } pub fn host(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .host_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.host_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn host_or_default(&self) -> roto_runtime::Result<&'a str> { + self.host().or(Ok("")) + } + + pub fn has_host(&self) -> bool { self.host_offset.is_some() } + pub fn port(&self) -> roto_runtime::Result { - let offset = self - .port_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.port_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn port_or_default(&self) -> roto_runtime::Result { + self.port().or(Ok(0)) + } + + pub fn has_port(&self) -> bool { self.port_offset.is_some() } + pub fn encrypted(&self) -> roto_runtime::Result { - let offset = self - .encrypted_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.encrypted_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v != 0) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn encrypted_or_default(&self) -> roto_runtime::Result { + self.encrypted().or(Ok(false)) + } + + pub fn has_encrypted(&self) -> bool { self.encrypted_offset.is_some() } + pub fn bandwidth_bps(&self) -> roto_runtime::Result { - let offset = self - .bandwidth_bps_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.bandwidth_bps_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn bandwidth_bps_or_default(&self) -> roto_runtime::Result { + self.bandwidth_bps().or(Ok(0)) + } + + pub fn has_bandwidth_bps(&self) -> bool { self.bandwidth_bps_offset.is_some() } + pub fn session_key(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .session_key_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.session_key_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } + pub fn session_key_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.session_key().or(Ok(&[])) + } + + pub fn has_session_key(&self) -> bool { self.session_key_offset.is_some() } + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct ConnectionBuilder<'b> { @@ -324,7 +359,7 @@ impl<'b> ConnectionBuilder<'b> { } pub fn with(mut self, msg: &Connection<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.host_written, @@ -346,6 +381,30 @@ impl<'b> ConnectionBuilder<'b> { } } +#[cfg(feature = "alloc")] +pub struct OwnedConnection { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedConnection { + type Reader<'a> = Connection<'a>; + fn reader(&self) -> Connection<'_> { + Connection::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedConnection { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedConnection { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct Hacker<'a> { accessor: roto_runtime::ProtoAccessor<'a>, handle_offset: Option, @@ -377,115 +436,109 @@ impl<'a> Hacker<'a> { let mut active_connection_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; - if tag.field_number == 1 { - handle_offset = Some(offset); - } - if tag.field_number == 2 { - real_name_offset = Some(offset); - } - if tag.field_number == 3 { - age_offset = Some(offset); - } - if tag.field_number == 4 { - skill_level_offset = Some(offset); - } - if tag.field_number == 5 { - is_elite_offset = Some(offset); - } - if tag.field_number == 6 { - crew_id_offset = Some(offset); - } + if tag.field_number == 1 { handle_offset = Some(offset); } + if tag.field_number == 2 { real_name_offset = Some(offset); } + if tag.field_number == 3 { age_offset = Some(offset); } + if tag.field_number == 4 { skill_level_offset = Some(offset); } + if tag.field_number == 5 { is_elite_offset = Some(offset); } + if tag.field_number == 6 { crew_id_offset = Some(offset); } if tag.field_number == 7 { - if exploits_start.is_none() { - exploits_start = Some(offset); - } + if exploits_start.is_none() { exploits_start = Some(offset); } exploits_end = Some(offset); } if tag.field_number == 8 { - if tools_start.is_none() { - tools_start = Some(offset); - } + if tools_start.is_none() { tools_start = Some(offset); } tools_end = Some(offset); } - if tag.field_number == 9 { - active_connection_offset = Some(offset); - } + if tag.field_number == 9 { active_connection_offset = Some(offset); } } Ok(Self { accessor, - handle_offset, - real_name_offset, - age_offset, - skill_level_offset, - is_elite_offset, - crew_id_offset, - exploits_start, - exploits_end, - tools_start, - tools_end, - active_connection_offset, +handle_offset, +real_name_offset, +age_offset, +skill_level_offset, +is_elite_offset, +crew_id_offset, +exploits_start, exploits_end, +tools_start, tools_end, +active_connection_offset, }) } pub fn handle(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .handle_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.handle_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn handle_or_default(&self) -> roto_runtime::Result<&'a str> { + self.handle().or(Ok("")) + } + + pub fn has_handle(&self) -> bool { self.handle_offset.is_some() } + pub fn real_name(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .real_name_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.real_name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn real_name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.real_name().or(Ok("")) + } + + pub fn has_real_name(&self) -> bool { self.real_name_offset.is_some() } + pub fn age(&self) -> roto_runtime::Result { - let offset = self - .age_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.age_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn age_or_default(&self) -> roto_runtime::Result { + self.age().or(Ok(0)) + } + + pub fn has_age(&self) -> bool { self.age_offset.is_some() } + pub fn skill_level(&self) -> roto_runtime::Result { - let offset = self - .skill_level_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.skill_level_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - Ok(f32::from_le_bytes( - bytes - .try_into() - .map_err(|_| RotoError::WireFormatViolation)?, - )) + Ok(f32::from_le_bytes(bytes.try_into().map_err(|_| roto_runtime::RotoError::WireFormatViolation)?)) } + pub fn skill_level_or_default(&self) -> roto_runtime::Result { + self.skill_level().or(Ok(0.0)) + } + + pub fn has_skill_level(&self) -> bool { self.skill_level_offset.is_some() } + pub fn is_elite(&self) -> roto_runtime::Result { - let offset = self - .is_elite_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.is_elite_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v != 0) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - pub fn crew_id(&self) -> roto_runtime::Result { - let offset = self - .crew_id_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + pub fn is_elite_or_default(&self) -> roto_runtime::Result { + self.is_elite().or(Ok(false)) } + pub fn has_is_elite(&self) -> bool { self.is_elite_offset.is_some() } + + pub fn crew_id(&self) -> roto_runtime::Result { + let offset = self.crew_id_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn crew_id_or_default(&self) -> roto_runtime::Result { + self.crew_id().or(Ok(0)) + } + + pub fn has_crew_id(&self) -> bool { self.crew_id_offset.is_some() } + pub fn exploits(&self) -> roto_runtime::RepeatedFieldIterator<'a> { match (self.exploits_start, self.exploits_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(7, start, end), @@ -501,16 +554,21 @@ impl<'a> Hacker<'a> { } pub fn active_connection(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .active_connection_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.active_connection_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } + pub fn active_connection_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.active_connection().or(Ok(&[])) + } + + pub fn has_active_connection(&self) -> bool { self.active_connection_offset.is_some() } + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct HackerBuilder<'b> { @@ -597,7 +655,7 @@ impl<'b> HackerBuilder<'b> { } pub fn with(mut self, msg: &Hacker<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.handle_written, @@ -623,6 +681,30 @@ impl<'b> HackerBuilder<'b> { } } +#[cfg(feature = "alloc")] +pub struct OwnedHacker { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedHacker { + type Reader<'a> = Hacker<'a>; + fn reader(&self) -> Hacker<'_> { + Hacker::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedHacker { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedHacker { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct Worm<'a> { accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, @@ -646,87 +728,88 @@ impl<'a> Worm<'a> { let mut targets_end = None; for item in accessor.fields() { let (offset, tag, _) = item?; - if tag.field_number == 1 { - name_offset = Some(offset); - } - if tag.field_number == 2 { - variant_offset = Some(offset); - } - if tag.field_number == 3 { - size_bytes_offset = Some(offset); - } - if tag.field_number == 4 { - payload_offset = Some(offset); - } - if tag.field_number == 5 { - polymorphic_offset = Some(offset); - } + if tag.field_number == 1 { name_offset = Some(offset); } + if tag.field_number == 2 { variant_offset = Some(offset); } + if tag.field_number == 3 { size_bytes_offset = Some(offset); } + if tag.field_number == 4 { payload_offset = Some(offset); } + if tag.field_number == 5 { polymorphic_offset = Some(offset); } if tag.field_number == 6 { - if targets_start.is_none() { - targets_start = Some(offset); - } + if targets_start.is_none() { targets_start = Some(offset); } targets_end = Some(offset); } } Ok(Self { accessor, - name_offset, - variant_offset, - size_bytes_offset, - payload_offset, - polymorphic_offset, - targets_start, - targets_end, +name_offset, +variant_offset, +size_bytes_offset, +payload_offset, +polymorphic_offset, +targets_start, targets_end, }) } pub fn name(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .name_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + pub fn variant(&self) -> roto_runtime::Result { - let offset = self - .variant_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.variant_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn variant_or_default(&self) -> roto_runtime::Result { + self.variant().or(Ok(0)) + } + + pub fn has_variant(&self) -> bool { self.variant_offset.is_some() } + pub fn size_bytes(&self) -> roto_runtime::Result { - let offset = self - .size_bytes_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.size_bytes_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn size_bytes_or_default(&self) -> roto_runtime::Result { + self.size_bytes().or(Ok(0)) + } + + pub fn has_size_bytes(&self) -> bool { self.size_bytes_offset.is_some() } + pub fn payload(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .payload_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.payload_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - pub fn polymorphic(&self) -> roto_runtime::Result { - let offset = self - .polymorphic_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; - let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v != 0) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + pub fn payload_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.payload().or(Ok(&[])) } + pub fn has_payload(&self) -> bool { self.payload_offset.is_some() } + + pub fn polymorphic(&self) -> roto_runtime::Result { + let offset = self.polymorphic_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn polymorphic_or_default(&self) -> roto_runtime::Result { + self.polymorphic().or(Ok(false)) + } + + pub fn has_polymorphic(&self) -> bool { self.polymorphic_offset.is_some() } + pub fn targets(&self) -> roto_runtime::RepeatedFieldIterator<'a> { match (self.targets_start, self.targets_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(6, start, end), @@ -737,6 +820,7 @@ impl<'a> Worm<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct WormBuilder<'b> { @@ -799,7 +883,7 @@ impl<'b> WormBuilder<'b> { } pub fn with(mut self, msg: &Worm<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -822,6 +906,30 @@ impl<'b> WormBuilder<'b> { } } +#[cfg(feature = "alloc")] +pub struct OwnedWorm { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedWorm { + type Reader<'a> = Worm<'a>; + fn reader(&self) -> Worm<'_> { + Worm::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedWorm { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedWorm { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct Operation<'a> { accessor: roto_runtime::ProtoAccessor<'a>, codename_offset: Option, @@ -853,101 +961,97 @@ impl<'a> Operation<'a> { let mut severity_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; - if tag.field_number == 1 { - codename_offset = Some(offset); - } - if tag.field_number == 2 { - target_corp_offset = Some(offset); - } - if tag.field_number == 3 { - timestamp_offset = Some(offset); - } - if tag.field_number == 4 { - successful_offset = Some(offset); - } - if tag.field_number == 5 { - stolen_data_offset = Some(offset); - } + if tag.field_number == 1 { codename_offset = Some(offset); } + if tag.field_number == 2 { target_corp_offset = Some(offset); } + if tag.field_number == 3 { timestamp_offset = Some(offset); } + if tag.field_number == 4 { successful_offset = Some(offset); } + if tag.field_number == 5 { stolen_data_offset = Some(offset); } if tag.field_number == 6 { - if crew_start.is_none() { - crew_start = Some(offset); - } + if crew_start.is_none() { crew_start = Some(offset); } crew_end = Some(offset); } - if tag.field_number == 7 { - worm_offset = Some(offset); - } + if tag.field_number == 7 { worm_offset = Some(offset); } if tag.field_number == 8 { - if log_entries_start.is_none() { - log_entries_start = Some(offset); - } + if log_entries_start.is_none() { log_entries_start = Some(offset); } log_entries_end = Some(offset); } - if tag.field_number == 9 { - severity_offset = Some(offset); - } + if tag.field_number == 9 { severity_offset = Some(offset); } } Ok(Self { accessor, - codename_offset, - target_corp_offset, - timestamp_offset, - successful_offset, - stolen_data_offset, - crew_start, - crew_end, - worm_offset, - log_entries_start, - log_entries_end, - severity_offset, +codename_offset, +target_corp_offset, +timestamp_offset, +successful_offset, +stolen_data_offset, +crew_start, crew_end, +worm_offset, +log_entries_start, log_entries_end, +severity_offset, }) } pub fn codename(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .codename_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.codename_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn codename_or_default(&self) -> roto_runtime::Result<&'a str> { + self.codename().or(Ok("")) + } + + pub fn has_codename(&self) -> bool { self.codename_offset.is_some() } + pub fn target_corp(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .target_corp_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.target_corp_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn target_corp_or_default(&self) -> roto_runtime::Result<&'a str> { + self.target_corp().or(Ok("")) + } + + pub fn has_target_corp(&self) -> bool { self.target_corp_offset.is_some() } + pub fn timestamp(&self) -> roto_runtime::Result { - let offset = self - .timestamp_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.timestamp_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn timestamp_or_default(&self) -> roto_runtime::Result { + self.timestamp().or(Ok(0)) + } + + pub fn has_timestamp(&self) -> bool { self.timestamp_offset.is_some() } + pub fn successful(&self) -> roto_runtime::Result { - let offset = self - .successful_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.successful_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v != 0) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn successful_or_default(&self) -> roto_runtime::Result { + self.successful().or(Ok(false)) + } + + pub fn has_successful(&self) -> bool { self.successful_offset.is_some() } + pub fn stolen_data(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .stolen_data_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.stolen_data_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } + pub fn stolen_data_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.stolen_data().or(Ok(&[])) + } + + pub fn has_stolen_data(&self) -> bool { self.stolen_data_offset.is_some() } + pub fn crew(&self) -> roto_runtime::RepeatedFieldIterator<'a> { match (self.crew_start, self.crew_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(6, start, end), @@ -956,13 +1060,17 @@ impl<'a> Operation<'a> { } pub fn worm(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .worm_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.worm_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } + pub fn worm_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.worm().or(Ok(&[])) + } + + pub fn has_worm(&self) -> bool { self.worm_offset.is_some() } + pub fn log_entries(&self) -> roto_runtime::RepeatedFieldIterator<'a> { match (self.log_entries_start, self.log_entries_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(8, start, end), @@ -971,18 +1079,21 @@ impl<'a> Operation<'a> { } pub fn severity(&self) -> roto_runtime::Result { - let offset = self - .severity_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.severity_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn severity_or_default(&self) -> roto_runtime::Result { + self.severity().or(Ok(0)) + } + + pub fn has_severity(&self) -> bool { self.severity_offset.is_some() } + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct OperationBuilder<'b> { @@ -1069,7 +1180,7 @@ impl<'b> OperationBuilder<'b> { } pub fn with(mut self, msg: &Operation<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.codename_written, @@ -1095,6 +1206,30 @@ impl<'b> OperationBuilder<'b> { } } +#[cfg(feature = "alloc")] +pub struct OwnedOperation { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedOperation { + type Reader<'a> = Operation<'a>; + fn reader(&self) -> Operation<'_> { + Operation::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedOperation { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedOperation { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + pub struct Campaign<'a> { accessor: roto_runtime::ProtoAccessor<'a>, name_offset: Option, @@ -1112,37 +1247,34 @@ impl<'a> Campaign<'a> { let mut total_bytes_stolen_offset = None; for item in accessor.fields() { let (offset, tag, _) = item?; - if tag.field_number == 1 { - name_offset = Some(offset); - } + if tag.field_number == 1 { name_offset = Some(offset); } if tag.field_number == 2 { - if operations_start.is_none() { - operations_start = Some(offset); - } + if operations_start.is_none() { operations_start = Some(offset); } operations_end = Some(offset); } - if tag.field_number == 3 { - total_bytes_stolen_offset = Some(offset); - } + if tag.field_number == 3 { total_bytes_stolen_offset = Some(offset); } } Ok(Self { accessor, - name_offset, - operations_start, - operations_end, - total_bytes_stolen_offset, +name_offset, +operations_start, operations_end, +total_bytes_stolen_offset, }) } pub fn name(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .name_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + pub fn operations(&self) -> roto_runtime::RepeatedFieldIterator<'a> { match (self.operations_start, self.operations_end) { (Some(start), Some(end)) => self.accessor.iter_repeated_range(2, start, end), @@ -1151,18 +1283,21 @@ impl<'a> Campaign<'a> { } pub fn total_bytes_stolen(&self) -> roto_runtime::Result { - let offset = self - .total_bytes_stolen_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + let offset = self.total_bytes_stolen_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - roto_runtime::read_varint(bytes) - .map(|(v, _)| v as i32) - .map_err(|_| roto_runtime::RotoError::WireFormatViolation) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } + pub fn total_bytes_stolen_or_default(&self) -> roto_runtime::Result { + self.total_bytes_stolen().or(Ok(0)) + } + + pub fn has_total_bytes_stolen(&self) -> bool { self.total_bytes_stolen_offset.is_some() } + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct CampaignBuilder<'b> { @@ -1201,7 +1336,7 @@ impl<'b> CampaignBuilder<'b> { } pub fn with(mut self, msg: &Campaign<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -1220,3 +1355,30 @@ impl<'b> CampaignBuilder<'b> { self.builder.finish() } } + +#[cfg(feature = "alloc")] +pub struct OwnedCampaign { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedCampaign { + type Reader<'a> = Campaign<'a>; + fn reader(&self) -> Campaign<'_> { + Campaign::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedCampaign { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedCampaign { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + + + diff --git a/examples/hello_world/proto/hello.rs b/examples/hello_world/proto/hello.rs index 78f898d..e89bf60 100644 --- a/examples/hello_world/proto/hello.rs +++ b/examples/hello_world/proto/hello.rs @@ -1,22 +1,9 @@ // @generated by protoc-gen-roto — do not edit #[allow(unused_imports)] - -use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator}; -use std::str; +use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator, RotoMessage}; +use core::str; +#[cfg(feature = "alloc")] 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}; - pub struct HelloRequest<'a> { accessor: roto_runtime::ProtoAccessor<'a>, @@ -41,7 +28,7 @@ name_offset, pub fn name(&self) -> roto_runtime::Result<&'a str> { let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { @@ -76,7 +63,7 @@ impl<'b> HelloRequestBuilder<'b> { } pub fn with(mut self, msg: &HelloRequest<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.name_written, @@ -94,10 +81,12 @@ impl<'b> HelloRequestBuilder<'b> { } } +#[cfg(feature = "alloc")] pub struct OwnedHelloRequest { pub data: bytes::Bytes, } +#[cfg(feature = "alloc")] impl roto_runtime::RotoOwned for OwnedHelloRequest { type Reader<'a> = HelloRequest<'a>; fn reader(&self) -> HelloRequest<'_> { @@ -105,6 +94,7 @@ impl roto_runtime::RotoOwned for OwnedHelloRequest { } } +#[cfg(feature = "alloc")] impl roto_runtime::RotoMessage for OwnedHelloRequest { fn decode(buf: bytes::Bytes) -> roto_runtime::Result { Ok(OwnedHelloRequest { data: buf }) @@ -138,7 +128,7 @@ message_offset, pub fn message(&self) -> roto_runtime::Result<&'a str> { let offset = self.message_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } pub fn message_or_default(&self) -> roto_runtime::Result<&'a str> { @@ -173,7 +163,7 @@ impl<'b> HelloResponseBuilder<'b> { } pub fn with(mut self, msg: &HelloResponse<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { + for item in msg.accessor.raw_fields() { let (field_number, raw_bytes) = item?; let is_written = match field_number { 1 => self.message_written, @@ -191,10 +181,12 @@ impl<'b> HelloResponseBuilder<'b> { } } +#[cfg(feature = "alloc")] pub struct OwnedHelloResponse { pub data: bytes::Bytes, } +#[cfg(feature = "alloc")] impl roto_runtime::RotoOwned for OwnedHelloResponse { type Reader<'a> = HelloResponse<'a>; fn reader(&self) -> HelloResponse<'_> { @@ -202,6 +194,7 @@ impl roto_runtime::RotoOwned for OwnedHelloResponse { } } +#[cfg(feature = "alloc")] impl roto_runtime::RotoMessage for OwnedHelloResponse { fn decode(buf: bytes::Bytes) -> roto_runtime::Result { Ok(OwnedHelloResponse { data: buf }) @@ -212,32 +205,65 @@ impl roto_runtime::RotoMessage for OwnedHelloResponse { } } -#[tonic::async_trait] + + +#[cfg(feature = "alloc")] +use tonic::{Request, Response, Status}; +#[cfg(feature = "alloc")] +use tokio_stream::Stream; +#[cfg(feature = "alloc")] +use std::pin::Pin; +#[cfg(feature = "alloc")] +use std::sync::Arc; +#[cfg(feature = "alloc")] +use std::task::{Context, Poll}; +#[cfg(feature = "alloc")] +use std::future::Future; +#[cfg(feature = "alloc")] +use tonic::body::BoxBody; +#[cfg(feature = "alloc")] +use tower::Service; +#[cfg(feature = "alloc")] +use futures_util::StreamExt; +#[cfg(feature = "alloc")] +use http_body_util::BodyExt; +#[cfg(feature = "alloc")] +use http_body::Body; +#[cfg(feature = "alloc")] +use crate::{BufferPool, StatusBody}; + +#[cfg(feature = "alloc")] +#[async_trait::async_trait] pub trait HelloWorldService: Send + Sync + 'static { async fn hello_world(&self, request: Request) -> std::result::Result, Status>; } +#[cfg(feature = "alloc")] +#[derive(Clone)] pub struct HelloWorldServiceServer { inner: Arc, pool: Arc, } +#[cfg(feature = "alloc")] impl HelloWorldServiceServer { pub fn new(inner: Arc, pool: Arc) -> Self { Self { inner, pool } } } +#[cfg(feature = "alloc")] impl tonic::server::NamedService for HelloWorldServiceServer { - const NAME: &'static str = "HelloWorldService"; + const NAME: &'static str = "hello.HelloWorldService"; } +#[cfg(feature = "alloc")] impl Service> for HelloWorldServiceServer { type Response = http::Response; type Error = std::convert::Infallible; - type Future = Pin> + Send>>; + type Future = Pin> + Send>>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { + fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { Poll::Ready(Ok(())) } @@ -245,13 +271,12 @@ impl Service> for HelloWorldServiceServer { let inner = self.inner.clone(); let pool = self.pool.clone(); Box::pin(async move { + let path = req.uri().path().to_string(); let body = req.into_body(); let mut buf = pool.get(); let mut stream = body; while let Some(frame_result) = stream.frame().await { - let frame = frame_result.map_err(|e| { - panic!("Body frame error: {}", e); - })?; + let frame = frame_result.expect("Body frame error"); if let Some(data) = frame.data_ref() { buf.put(data.clone()); } @@ -261,30 +286,29 @@ impl Service> for HelloWorldServiceServer { let bytes_vec = buf.split_to(total_len).freeze(); pool.put(buf); if bytes_vec.len() < 5 { - let res_body = BoxBody::new(StatusBody(Some(Bytes::from_static(&[0, 0, 0, 0, 0])))); + let res_body = BoxBody::new(StatusBody::new(Some(Bytes::from_static(&[0, 0, 0, 0, 0])), 0)); return Ok(http::Response::builder().status(200).body(res_body).unwrap()); } let payload = bytes_vec.slice(5..); - let path = req.uri().path(); let mut routed = false; - if path == "/HelloWorldService/hello_world" { + if path == "/hello.HelloWorldService/HelloWorld" { let request_msg = match OwnedHelloRequest::decode(payload) { Ok(msg) => msg, Err(e) => { - let res_body = BoxBody::new(StatusBody(Some(Bytes::from_static(&[0, 0, 0, 0, 0])))); + let res_body = BoxBody::new(StatusBody::new(Some(Bytes::from_static(&[0, 0, 0, 0, 0])), 0)); return Ok(http::Response::builder().status(200).body(res_body).unwrap()); } - }}; + }; let response = match inner.hello_world(Request::new(request_msg)).await { Ok(res) => res, Err(e) => { - let res_body = BoxBody::new(StatusBody(Some(Bytes::from_static(&[0, 0, 0, 0, 0])))); + let res_body = BoxBody::new(StatusBody::new(Some(Bytes::from_static(&[0, 0, 0, 0, 0])), 0)); return Ok(http::Response::builder().status(200).body(res_body).unwrap()); } - }}; + }; let response_msg = response.into_inner(); let response_bytes = response_msg.bytes(); @@ -296,15 +320,15 @@ impl Service> for HelloWorldServiceServer { let frame_len = res_buf.len(); let frame = res_buf.split_to(frame_len).freeze(); pool.put(res_buf); - let res_body = BoxBody::new(StatusBody(Some(frame))); + let res_body = BoxBody::new(StatusBody::new(Some(frame), 0)); routed = true; return Ok(http::Response::builder().status(200).header("content-type", "application/grpc").body(res_body).unwrap()); } if !routed { - let res_body = BoxBody::new(StatusBody(Some(Bytes::from_static(&[0, 0, 0, 0, 0])))); + let res_body = BoxBody::new(StatusBody::new(Some(Bytes::from_static(&[0, 0, 0, 0, 0])), 0)); return Ok(http::Response::builder().status(200).body(res_body).unwrap()); } - Ok(http::Response::builder().status(200).body(BoxBody::new(StatusBody(None))).unwrap()) + Ok(http::Response::builder().status(200).body(BoxBody::new(StatusBody::new(None, 0))).unwrap()) }) } } diff --git a/examples/no_std_test/src/helloworld.rs b/examples/no_std_test/src/helloworld.rs index 1a7e2a7..57ed633 100644 --- a/examples/no_std_test/src/helloworld.rs +++ b/examples/no_std_test/src/helloworld.rs @@ -1,8 +1,8 @@ // @generated by protoc-gen-roto — do not edit #[allow(unused_imports)] - use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator, RotoMessage}; use core::str; +#[cfg(feature = "alloc")] use bytes::{Bytes, BytesMut, Buf, BufMut}; pub struct Hello<'a> { @@ -675,3 +675,131 @@ impl roto_runtime::RotoMessage for OwnedHelloReply { self.data.clone() } } + + + +#[cfg(feature = "alloc")] +use tonic::{Request, Response, Status}; +#[cfg(feature = "alloc")] +use tokio_stream::Stream; +#[cfg(feature = "alloc")] +use std::pin::Pin; +#[cfg(feature = "alloc")] +use std::sync::Arc; +#[cfg(feature = "alloc")] +use std::task::{Context, Poll}; +#[cfg(feature = "alloc")] +use std::future::Future; +#[cfg(feature = "alloc")] +use tonic::body::BoxBody; +#[cfg(feature = "alloc")] +use tower::Service; +#[cfg(feature = "alloc")] +use futures_util::StreamExt; +#[cfg(feature = "alloc")] +use http_body_util::BodyExt; +#[cfg(feature = "alloc")] +use http_body::Body; +#[cfg(feature = "alloc")] +use crate::{BufferPool, StatusBody}; + +#[cfg(feature = "alloc")] +#[async_trait::async_trait] +pub trait Greeter: Send + Sync + 'static { + async fn say_hello(&self, request: Request) -> std::result::Result, Status>; +} + +#[cfg(feature = "alloc")] +#[derive(Clone)] +pub struct GreeterServer { + inner: Arc, + pool: Arc, +} + +#[cfg(feature = "alloc")] +impl GreeterServer { + pub fn new(inner: Arc, pool: Arc) -> Self { + Self { inner, pool } + } +} + +#[cfg(feature = "alloc")] +impl tonic::server::NamedService for GreeterServer { + const NAME: &'static str = "helloworld.Greeter"; +} + +#[cfg(feature = "alloc")] +impl Service> for GreeterServer { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = Pin> + Send>>; + + fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { + Poll::Ready(Ok(())) + } + + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + let pool = self.pool.clone(); + Box::pin(async move { + let path = req.uri().path().to_string(); + let body = req.into_body(); + let mut buf = pool.get(); + let mut stream = body; + while let Some(frame_result) = stream.frame().await { + let frame = frame_result.expect("Body frame error"); + if let Some(data) = frame.data_ref() { + buf.put(data.clone()); + } + } + + let total_len = buf.len(); + let bytes_vec = buf.split_to(total_len).freeze(); + pool.put(buf); + if bytes_vec.len() < 5 { + let res_body = BoxBody::new(StatusBody::new(Some(Bytes::from_static(&[0, 0, 0, 0, 0])), 0)); + return Ok(http::Response::builder().status(200).body(res_body).unwrap()); + } + + let payload = bytes_vec.slice(5..); + let mut routed = false; + + if path == "/helloworld.Greeter/SayHello" { + let request_msg = match OwnedHelloRequest::decode(payload) { + Ok(msg) => msg, + Err(e) => { + let res_body = BoxBody::new(StatusBody::new(Some(Bytes::from_static(&[0, 0, 0, 0, 0])), 0)); + return Ok(http::Response::builder().status(200).body(res_body).unwrap()); + } + }; + + let response = match inner.say_hello(Request::new(request_msg)).await { + Ok(res) => res, + Err(e) => { + let res_body = BoxBody::new(StatusBody::new(Some(Bytes::from_static(&[0, 0, 0, 0, 0])), 0)); + return Ok(http::Response::builder().status(200).body(res_body).unwrap()); + } + }; + + let response_msg = response.into_inner(); + let response_bytes = response_msg.bytes(); + let mut res_buf = pool.get(); + res_buf.put_u8(0); + let len = response_bytes.len() as u32; + res_buf.put_slice(&len.to_be_bytes()); + res_buf.put_slice(&response_bytes); + let frame_len = res_buf.len(); + let frame = res_buf.split_to(frame_len).freeze(); + pool.put(res_buf); + let res_body = BoxBody::new(StatusBody::new(Some(frame), 0)); + routed = true; + return Ok(http::Response::builder().status(200).header("content-type", "application/grpc").body(res_body).unwrap()); + } + if !routed { + let res_body = BoxBody::new(StatusBody::new(Some(Bytes::from_static(&[0, 0, 0, 0, 0])), 0)); + return Ok(http::Response::builder().status(200).body(res_body).unwrap()); + } + Ok(http::Response::builder().status(200).body(BoxBody::new(StatusBody::new(None, 0))).unwrap()) + }) + } +} diff --git a/roto/benches/src/google/protobuf/compiler/plugin.rs b/roto/benches/src/google/protobuf/compiler/plugin.rs new file mode 100644 index 0000000..effdda2 --- /dev/null +++ b/roto/benches/src/google/protobuf/compiler/plugin.rs @@ -0,0 +1,783 @@ +// @generated by protoc-gen-roto — do not edit +#[allow(unused_imports)] +use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator, RotoMessage}; +use core::str; +#[cfg(feature = "alloc")] +use bytes::{Bytes, BytesMut, Buf, BufMut}; +use crate::google::protobuf::descriptor; + +pub struct Version<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + major_offset: Option, + minor_offset: Option, + patch_offset: Option, + suffix_offset: Option, +} + +impl<'a> Version<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; + let mut major_offset = None; + let mut minor_offset = None; + let mut patch_offset = None; + let mut suffix_offset = None; + for item in accessor.fields() { + let (offset, tag, _) = item?; + if tag.field_number == 1 { major_offset = Some(offset); } + if tag.field_number == 2 { minor_offset = Some(offset); } + if tag.field_number == 3 { patch_offset = Some(offset); } + if tag.field_number == 4 { suffix_offset = Some(offset); } + } + + Ok(Self { + accessor, +major_offset, +minor_offset, +patch_offset, +suffix_offset, + }) + } + + pub fn major(&self) -> roto_runtime::Result { + let offset = self.major_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn major_or_default(&self) -> roto_runtime::Result { + self.major().or(Ok(0)) + } + + pub fn has_major(&self) -> bool { self.major_offset.is_some() } + + pub fn minor(&self) -> roto_runtime::Result { + let offset = self.minor_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn minor_or_default(&self) -> roto_runtime::Result { + self.minor().or(Ok(0)) + } + + pub fn has_minor(&self) -> bool { self.minor_offset.is_some() } + + pub fn patch(&self) -> roto_runtime::Result { + let offset = self.patch_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn patch_or_default(&self) -> roto_runtime::Result { + self.patch().or(Ok(0)) + } + + pub fn has_patch(&self) -> bool { self.patch_offset.is_some() } + + pub fn suffix(&self) -> roto_runtime::Result<&'a str> { + let offset = self.suffix_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn suffix_or_default(&self) -> roto_runtime::Result<&'a str> { + self.suffix().or(Ok("")) + } + + pub fn has_suffix(&self) -> bool { self.suffix_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct VersionBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + major_written: bool, + minor_written: bool, + patch_written: bool, + suffix_written: bool, +} + +impl<'b> VersionBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> VersionBuilder<'_> { + VersionBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + major_written: false, + minor_written: false, + patch_written: false, + suffix_written: false, + } + } + + pub fn major(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.major_written = true; + Ok(self) + } + + pub fn minor(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(2, value)?; + self.minor_written = true; + Ok(self) + } + + pub fn patch(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(3, value)?; + self.patch_written = true; + Ok(self) + } + + pub fn suffix(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(4, value)?; + self.suffix_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Version<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.major_written, + 2 => self.minor_written, + 3 => self.patch_written, + 4 => self.suffix_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } + Ok(self) + } + + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedVersion { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedVersion { + type Reader<'a> = Version<'a>; + fn reader(&self) -> Version<'_> { + Version::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedVersion { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedVersion { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct CodeGeneratorRequest<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + file_to_generate_start: Option, + file_to_generate_end: Option, + parameter_offset: Option, + proto_file_start: Option, + proto_file_end: Option, + source_file_descriptors_start: Option, + source_file_descriptors_end: Option, + compiler_version_offset: Option, +} + +impl<'a> CodeGeneratorRequest<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; + let mut file_to_generate_start = None; + let mut file_to_generate_end = None; + let mut parameter_offset = None; + let mut proto_file_start = None; + let mut proto_file_end = None; + let mut source_file_descriptors_start = None; + let mut source_file_descriptors_end = None; + let mut compiler_version_offset = None; + for item in accessor.fields() { + let (offset, tag, _) = item?; + if tag.field_number == 1 { + if file_to_generate_start.is_none() { file_to_generate_start = Some(offset); } + file_to_generate_end = Some(offset); + } + if tag.field_number == 2 { parameter_offset = Some(offset); } + if tag.field_number == 15 { + if proto_file_start.is_none() { proto_file_start = Some(offset); } + proto_file_end = Some(offset); + } + if tag.field_number == 17 { + if source_file_descriptors_start.is_none() { source_file_descriptors_start = Some(offset); } + source_file_descriptors_end = Some(offset); + } + if tag.field_number == 3 { compiler_version_offset = Some(offset); } + } + + Ok(Self { + accessor, +file_to_generate_start, file_to_generate_end, +parameter_offset, +proto_file_start, proto_file_end, +source_file_descriptors_start, source_file_descriptors_end, +compiler_version_offset, + }) + } + + pub fn file_to_generate(&self) -> roto_runtime::RepeatedFieldIterator<'a> { + match (self.file_to_generate_start, self.file_to_generate_end) { + (Some(start), Some(end)) => self.accessor.iter_repeated_range(1, start, end), + _ => self.accessor.iter_repeated(1), + } + } + + pub fn parameter(&self) -> roto_runtime::Result<&'a str> { + let offset = self.parameter_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn parameter_or_default(&self) -> roto_runtime::Result<&'a str> { + self.parameter().or(Ok("")) + } + + pub fn has_parameter(&self) -> bool { self.parameter_offset.is_some() } + + pub fn proto_file(&self) -> roto_runtime::RepeatedFieldIterator<'a> { + match (self.proto_file_start, self.proto_file_end) { + (Some(start), Some(end)) => self.accessor.iter_repeated_range(15, start, end), + _ => self.accessor.iter_repeated(15), + } + } + + pub fn source_file_descriptors(&self) -> roto_runtime::RepeatedFieldIterator<'a> { + match (self.source_file_descriptors_start, self.source_file_descriptors_end) { + (Some(start), Some(end)) => self.accessor.iter_repeated_range(17, start, end), + _ => self.accessor.iter_repeated(17), + } + } + + pub fn compiler_version(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.compiler_version_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn compiler_version_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.compiler_version().or(Ok(&[])) + } + + pub fn has_compiler_version(&self) -> bool { self.compiler_version_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct CodeGeneratorRequestBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + file_to_generate_written: bool, + parameter_written: bool, + proto_file_written: bool, + source_file_descriptors_written: bool, + compiler_version_written: bool, +} + +impl<'b> CodeGeneratorRequestBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> CodeGeneratorRequestBuilder<'_> { + CodeGeneratorRequestBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + file_to_generate_written: false, + parameter_written: false, + proto_file_written: false, + source_file_descriptors_written: false, + compiler_version_written: false, + } + } + + pub fn file_to_generate(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.file_to_generate_written = true; + Ok(self) + } + + pub fn parameter(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(2, value)?; + self.parameter_written = true; + Ok(self) + } + + pub fn proto_file(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(15, value)?; + self.proto_file_written = true; + Ok(self) + } + + pub fn source_file_descriptors(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(17, value)?; + self.source_file_descriptors_written = true; + Ok(self) + } + + pub fn compiler_version(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(3, value)?; + self.compiler_version_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &CodeGeneratorRequest<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.file_to_generate_written, + 2 => self.parameter_written, + 15 => self.proto_file_written, + 17 => self.source_file_descriptors_written, + 3 => self.compiler_version_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } + Ok(self) + } + + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedCodeGeneratorRequest { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedCodeGeneratorRequest { + type Reader<'a> = CodeGeneratorRequest<'a>; + fn reader(&self) -> CodeGeneratorRequest<'_> { + CodeGeneratorRequest::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedCodeGeneratorRequest { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedCodeGeneratorRequest { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct CodeGeneratorResponse<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + error_offset: Option, + supported_features_offset: Option, + minimum_edition_offset: Option, + maximum_edition_offset: Option, + file_start: Option, + file_end: Option, +} + +impl<'a> CodeGeneratorResponse<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; + let mut error_offset = None; + let mut supported_features_offset = None; + let mut minimum_edition_offset = None; + let mut maximum_edition_offset = None; + let mut file_start = None; + let mut file_end = None; + for item in accessor.fields() { + let (offset, tag, _) = item?; + if tag.field_number == 1 { error_offset = Some(offset); } + if tag.field_number == 2 { supported_features_offset = Some(offset); } + if tag.field_number == 3 { minimum_edition_offset = Some(offset); } + if tag.field_number == 4 { maximum_edition_offset = Some(offset); } + if tag.field_number == 15 { + if file_start.is_none() { file_start = Some(offset); } + file_end = Some(offset); + } + } + + Ok(Self { + accessor, +error_offset, +supported_features_offset, +minimum_edition_offset, +maximum_edition_offset, +file_start, file_end, + }) + } + + pub fn error(&self) -> roto_runtime::Result<&'a str> { + let offset = self.error_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn error_or_default(&self) -> roto_runtime::Result<&'a str> { + self.error().or(Ok("")) + } + + pub fn has_error(&self) -> bool { self.error_offset.is_some() } + + pub fn supported_features(&self) -> roto_runtime::Result { + let offset = self.supported_features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn supported_features_or_default(&self) -> roto_runtime::Result { + self.supported_features().or(Ok(0)) + } + + pub fn has_supported_features(&self) -> bool { self.supported_features_offset.is_some() } + + pub fn minimum_edition(&self) -> roto_runtime::Result { + let offset = self.minimum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn minimum_edition_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.maximum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn maximum_edition_or_default(&self) -> roto_runtime::Result { + self.maximum_edition().or(Ok(0)) + } + + pub fn has_maximum_edition(&self) -> bool { self.maximum_edition_offset.is_some() } + + pub fn file(&self) -> roto_runtime::RepeatedFieldIterator<'a> { + match (self.file_start, self.file_end) { + (Some(start), Some(end)) => self.accessor.iter_repeated_range(15, start, end), + _ => self.accessor.iter_repeated(15), + } + } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct CodeGeneratorResponseBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + error_written: bool, + supported_features_written: bool, + minimum_edition_written: bool, + maximum_edition_written: bool, + file_written: bool, +} + +impl<'b> CodeGeneratorResponseBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> CodeGeneratorResponseBuilder<'_> { + CodeGeneratorResponseBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + error_written: false, + supported_features_written: false, + minimum_edition_written: false, + maximum_edition_written: false, + file_written: false, + } + } + + pub fn error(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.error_written = true; + Ok(self) + } + + pub fn supported_features(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(2, value)?; + self.supported_features_written = true; + Ok(self) + } + + pub fn minimum_edition(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(3, value)?; + self.minimum_edition_written = true; + Ok(self) + } + + pub fn maximum_edition(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(4, value)?; + self.maximum_edition_written = true; + Ok(self) + } + + pub fn file(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(15, value)?; + self.file_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &CodeGeneratorResponse<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.error_written, + 2 => self.supported_features_written, + 3 => self.minimum_edition_written, + 4 => self.maximum_edition_written, + 15 => self.file_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } + Ok(self) + } + + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedCodeGeneratorResponse { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedCodeGeneratorResponse { + type Reader<'a> = CodeGeneratorResponse<'a>; + fn reader(&self) -> CodeGeneratorResponse<'_> { + CodeGeneratorResponse::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedCodeGeneratorResponse { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedCodeGeneratorResponse { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub mod code_generator_response { +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[repr(i32)] +pub enum Feature { + FEATURENONE = 0, + FEATUREPROTO3OPTIONAL = 1, + FEATURESUPPORTSEDITIONS = 2, +} + +impl Feature { + pub fn from_i32(value: i32) -> Self { + match value { + 0 => Feature::FEATURENONE, + 1 => Feature::FEATUREPROTO3OPTIONAL, + 2 => Feature::FEATURESUPPORTSEDITIONS, + _ => Feature::FEATURENONE, + } + } +} + +pub struct File<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + name_offset: Option, + insertion_point_offset: Option, + content_offset: Option, + generated_code_info_offset: Option, +} + +impl<'a> File<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; + let mut name_offset = None; + let mut insertion_point_offset = None; + let mut content_offset = None; + let mut generated_code_info_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 { insertion_point_offset = Some(offset); } + if tag.field_number == 15 { content_offset = Some(offset); } + if tag.field_number == 16 { generated_code_info_offset = Some(offset); } + } + + Ok(Self { + accessor, +name_offset, +insertion_point_offset, +content_offset, +generated_code_info_offset, + }) + } + + pub fn name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn insertion_point(&self) -> roto_runtime::Result<&'a str> { + let offset = self.insertion_point_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn insertion_point_or_default(&self) -> roto_runtime::Result<&'a str> { + self.insertion_point().or(Ok("")) + } + + pub fn has_insertion_point(&self) -> bool { self.insertion_point_offset.is_some() } + + pub fn content(&self) -> roto_runtime::Result<&'a str> { + let offset = self.content_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn content_or_default(&self) -> roto_runtime::Result<&'a str> { + self.content().or(Ok("")) + } + + pub fn has_content(&self) -> bool { self.content_offset.is_some() } + + pub fn generated_code_info(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.generated_code_info_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn generated_code_info_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.generated_code_info().or(Ok(&[])) + } + + pub fn has_generated_code_info(&self) -> bool { self.generated_code_info_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FileBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + name_written: bool, + insertion_point_written: bool, + content_written: bool, + generated_code_info_written: bool, +} + +impl<'b> FileBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> FileBuilder<'_> { + FileBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + name_written: false, + insertion_point_written: false, + content_written: false, + generated_code_info_written: false, + } + } + + pub fn name(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_written = true; + Ok(self) + } + + pub fn insertion_point(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(2, value)?; + self.insertion_point_written = true; + Ok(self) + } + + pub fn content(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(15, value)?; + self.content_written = true; + Ok(self) + } + + pub fn generated_code_info(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(16, value)?; + self.generated_code_info_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &File<'_>) -> roto_runtime::Result { + for item in msg.accessor.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.name_written, + 2 => self.insertion_point_written, + 15 => self.content_written, + 16 => self.generated_code_info_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } + Ok(self) + } + + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFile { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFile { + type Reader<'a> = File<'a>; + fn reader(&self) -> File<'_> { + File::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFile { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFile { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +} + + +use crate::google::protobuf::descriptor; + diff --git a/roto/benches/src/google/protobuf/descriptor.rs b/roto/benches/src/google/protobuf/descriptor.rs new file mode 100644 index 0000000..b79e624 --- /dev/null +++ b/roto/benches/src/google/protobuf/descriptor.rs @@ -0,0 +1,7578 @@ +// @generated by protoc-gen-roto — do not edit +#[allow(unused_imports)] +use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator, RotoMessage}; +use core::str; +#[cfg(feature = "alloc")] +use bytes::{Bytes, BytesMut, Buf, BufMut}; + +#[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: roto_runtime::ProtoAccessor<'a>, + file_start: Option, + file_end: Option, +} + +impl<'a> FileDescriptorSet<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FileDescriptorSetBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + file_written: bool, +} + +impl<'b> FileDescriptorSetBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> FileDescriptorSetBuilder<'_> { + FileDescriptorSetBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + file_written: false, + } + } + + pub fn file(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(1, value)?; + self.file_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FileDescriptorSet<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFileDescriptorSet { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFileDescriptorSet { + type Reader<'a> = FileDescriptorSet<'a>; + fn reader(&self) -> FileDescriptorSet<'_> { + FileDescriptorSet::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFileDescriptorSet { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFileDescriptorSet { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct FileDescriptorProto<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn package(&self) -> roto_runtime::Result<&'a str> { + let offset = self.package_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn package_or_default(&self) -> roto_runtime::Result<&'a str> { + self.package().or(Ok("")) + } + + pub fn has_package(&self) -> bool { self.package_offset.is_some() } + + pub fn dependency(&self) -> roto_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) -> roto_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) -> roto_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) -> roto_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) -> roto_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) -> roto_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) -> roto_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) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn options_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.source_code_info_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn source_code_info_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.syntax_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn syntax_or_default(&self) -> roto_runtime::Result<&'a str> { + self.syntax().or(Ok("")) + } + + pub fn has_syntax(&self) -> bool { self.syntax_offset.is_some() } + + pub fn edition(&self) -> roto_runtime::Result { + let offset = self.edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn edition_or_default(&self) -> roto_runtime::Result { + self.edition().or(Ok(0)) + } + + pub fn has_edition(&self) -> bool { self.edition_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FileDescriptorProtoBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_written = true; + Ok(self) + } + + pub fn package(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(2, value)?; + self.package_written = true; + Ok(self) + } + + pub fn dependency(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(3, value)?; + self.dependency_written = true; + Ok(self) + } + + pub fn public_dependency(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(10, value)?; + self.public_dependency_written = true; + Ok(self) + } + + pub fn weak_dependency(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(11, value)?; + self.weak_dependency_written = true; + Ok(self) + } + + pub fn option_dependency(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(15, value)?; + self.option_dependency_written = true; + Ok(self) + } + + pub fn message_type(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(4, value)?; + self.message_type_written = true; + Ok(self) + } + + pub fn enum_type(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(5, value)?; + self.enum_type_written = true; + Ok(self) + } + + pub fn service(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(6, value)?; + self.service_written = true; + Ok(self) + } + + pub fn extension(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(7, value)?; + self.extension_written = true; + Ok(self) + } + + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(8, value)?; + self.options_written = true; + Ok(self) + } + + pub fn source_code_info(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(9, value)?; + self.source_code_info_written = true; + Ok(self) + } + + pub fn syntax(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(12, value)?; + self.syntax_written = true; + Ok(self) + } + + pub fn edition(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(14, value)?; + self.edition_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FileDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFileDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFileDescriptorProto { + type Reader<'a> = FileDescriptorProto<'a>; + fn reader(&self) -> FileDescriptorProto<'_> { + FileDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFileDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFileDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct DescriptorProto<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn field(&self) -> roto_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) -> roto_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) -> roto_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) -> roto_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) -> roto_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) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn reserved_range(&self) -> roto_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) -> roto_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) -> roto_runtime::Result { + let offset = self.visibility_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn visibility_or_default(&self) -> roto_runtime::Result { + self.visibility().or(Ok(0)) + } + + pub fn has_visibility(&self) -> bool { self.visibility_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct DescriptorProtoBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_written = true; + Ok(self) + } + + pub fn field(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(2, value)?; + self.field_written = true; + Ok(self) + } + + pub fn extension(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(6, value)?; + self.extension_written = true; + Ok(self) + } + + pub fn nested_type(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(3, value)?; + self.nested_type_written = true; + Ok(self) + } + + pub fn enum_type(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(4, value)?; + self.enum_type_written = true; + Ok(self) + } + + pub fn extension_range(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(5, value)?; + self.extension_range_written = true; + Ok(self) + } + + pub fn oneof_decl(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(8, value)?; + self.oneof_decl_written = true; + Ok(self) + } + + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(7, value)?; + self.options_written = true; + Ok(self) + } + + pub fn reserved_range(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(9, value)?; + self.reserved_range_written = true; + Ok(self) + } + + pub fn reserved_name(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(10, value)?; + self.reserved_name_written = true; + Ok(self) + } + + pub fn visibility(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(11, value)?; + self.visibility_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &DescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedDescriptorProto { + type Reader<'a> = DescriptorProto<'a>; + fn reader(&self) -> DescriptorProto<'_> { + DescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub mod descriptor_proto { +pub struct ExtensionRange<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + start_offset: Option, + end_offset: Option, + options_offset: Option, +} + +impl<'a> ExtensionRange<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.start_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn start_or_default(&self) -> roto_runtime::Result { + self.start().or(Ok(0)) + } + + pub fn has_start(&self) -> bool { self.start_offset.is_some() } + + pub fn end(&self) -> roto_runtime::Result { + let offset = self.end_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } + + pub fn has_end(&self) -> bool { self.end_offset.is_some() } + + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct ExtensionRangeBuilder<'b> { + builder: roto_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: roto_runtime::ProtoBuilder::new(buf), + start_written: false, + end_written: false, + options_written: false, + } + } + + pub fn start(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.start_written = true; + Ok(self) + } + + pub fn end(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(2, value)?; + self.end_written = true; + Ok(self) + } + + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(3, value)?; + self.options_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ExtensionRange<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedExtensionRange { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedExtensionRange { + type Reader<'a> = ExtensionRange<'a>; + fn reader(&self) -> ExtensionRange<'_> { + ExtensionRange::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedExtensionRange { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedExtensionRange { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct ReservedRange<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + start_offset: Option, + end_offset: Option, +} + +impl<'a> ReservedRange<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.start_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn start_or_default(&self) -> roto_runtime::Result { + self.start().or(Ok(0)) + } + + pub fn has_start(&self) -> bool { self.start_offset.is_some() } + + pub fn end(&self) -> roto_runtime::Result { + let offset = self.end_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } + + pub fn has_end(&self) -> bool { self.end_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct ReservedRangeBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + start_written: bool, + end_written: bool, +} + +impl<'b> ReservedRangeBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> ReservedRangeBuilder<'_> { + ReservedRangeBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + start_written: false, + end_written: false, + } + } + + pub fn start(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.start_written = true; + Ok(self) + } + + pub fn end(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(2, value)?; + self.end_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ReservedRange<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedReservedRange { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedReservedRange { + type Reader<'a> = ReservedRange<'a>; + fn reader(&self) -> ReservedRange<'_> { + ReservedRange::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedReservedRange { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedReservedRange { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +} + +pub struct ExtensionRangeOptions<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_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) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn verification(&self) -> roto_runtime::Result { + let offset = self.verification_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn verification_or_default(&self) -> roto_runtime::Result { + self.verification().or(Ok(0)) + } + + pub fn has_verification(&self) -> bool { self.verification_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct ExtensionRangeOptionsBuilder<'b> { + builder: roto_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: roto_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]) -> roto_runtime::Result { + self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn declaration(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(2, value)?; + self.declaration_written = true; + Ok(self) + } + + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(50, value)?; + self.features_written = true; + Ok(self) + } + + pub fn verification(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(3, value)?; + self.verification_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ExtensionRangeOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedExtensionRangeOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedExtensionRangeOptions { + type Reader<'a> = ExtensionRangeOptions<'a>; + fn reader(&self) -> ExtensionRangeOptions<'_> { + ExtensionRangeOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedExtensionRangeOptions { + fn decode(buf: bytes::Bytes) -> roto_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: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.number_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn number_or_default(&self) -> roto_runtime::Result { + self.number().or(Ok(0)) + } + + pub fn has_number(&self) -> bool { self.number_offset.is_some() } + + pub fn full_name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.full_name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn full_name_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn r#type_or_default(&self) -> roto_runtime::Result<&'a str> { + self.r#type().or(Ok("")) + } + + pub fn has_type(&self) -> bool { self.type_offset.is_some() } + + pub fn reserved(&self) -> roto_runtime::Result { + let offset = self.reserved_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn reserved_or_default(&self) -> roto_runtime::Result { + self.reserved().or(Ok(false)) + } + + pub fn has_reserved(&self) -> bool { self.reserved_offset.is_some() } + + pub fn repeated(&self) -> roto_runtime::Result { + let offset = self.repeated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn repeated_or_default(&self) -> roto_runtime::Result { + self.repeated().or(Ok(false)) + } + + pub fn has_repeated(&self) -> bool { self.repeated_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct DeclarationBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.number_written = true; + Ok(self) + } + + pub fn full_name(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(2, value)?; + self.full_name_written = true; + Ok(self) + } + + pub fn r#type(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(3, value)?; + self.type_written = true; + Ok(self) + } + + pub fn reserved(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(5, value)?; + self.reserved_written = true; + Ok(self) + } + + pub fn repeated(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(6, value)?; + self.repeated_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Declaration<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedDeclaration { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedDeclaration { + type Reader<'a> = Declaration<'a>; + fn reader(&self) -> Declaration<'_> { + Declaration::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedDeclaration { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedDeclaration { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +} + +pub struct FieldDescriptorProto<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn number(&self) -> roto_runtime::Result { + let offset = self.number_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn number_or_default(&self) -> roto_runtime::Result { + self.number().or(Ok(0)) + } + + pub fn has_number(&self) -> bool { self.number_offset.is_some() } + + pub fn label(&self) -> roto_runtime::Result { + let offset = self.label_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn label_or_default(&self) -> roto_runtime::Result { + self.label().or(Ok(0)) + } + + pub fn has_label(&self) -> bool { self.label_offset.is_some() } + + pub fn r#type(&self) -> roto_runtime::Result { + let offset = self.type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn r#type_or_default(&self) -> roto_runtime::Result { + self.r#type().or(Ok(0)) + } + + pub fn has_type(&self) -> bool { self.type_offset.is_some() } + + pub fn type_name(&self) -> roto_runtime::Result<&'a str> { + let offset = self.type_name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn type_name_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.extendee_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn extendee_or_default(&self) -> roto_runtime::Result<&'a str> { + self.extendee().or(Ok("")) + } + + pub fn has_extendee(&self) -> bool { self.extendee_offset.is_some() } + + pub fn default_value(&self) -> roto_runtime::Result<&'a str> { + let offset = self.default_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn default_value_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.oneof_index_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn oneof_index_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.json_name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn json_name_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn proto3_optional(&self) -> roto_runtime::Result { + let offset = self.proto3_optional_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn proto3_optional_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FieldDescriptorProtoBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_written = true; + Ok(self) + } + + pub fn number(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(3, value)?; + self.number_written = true; + Ok(self) + } + + pub fn label(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(4, value)?; + self.label_written = true; + Ok(self) + } + + pub fn r#type(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(5, value)?; + self.type_written = true; + Ok(self) + } + + pub fn type_name(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(6, value)?; + self.type_name_written = true; + Ok(self) + } + + pub fn extendee(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(2, value)?; + self.extendee_written = true; + Ok(self) + } + + pub fn default_value(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(7, value)?; + self.default_value_written = true; + Ok(self) + } + + pub fn oneof_index(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(9, value)?; + self.oneof_index_written = true; + Ok(self) + } + + pub fn json_name(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(10, value)?; + self.json_name_written = true; + Ok(self) + } + + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(8, value)?; + self.options_written = true; + Ok(self) + } + + pub fn proto3_optional(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(17, value)?; + self.proto3_optional_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FieldDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFieldDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFieldDescriptorProto { + type Reader<'a> = FieldDescriptorProto<'a>; + fn reader(&self) -> FieldDescriptorProto<'_> { + FieldDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFieldDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_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: roto_runtime::ProtoAccessor<'a>, + name_offset: Option, + options_offset: Option, +} + +impl<'a> OneofDescriptorProto<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct OneofDescriptorProtoBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + name_written: bool, + options_written: bool, +} + +impl<'b> OneofDescriptorProtoBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> OneofDescriptorProtoBuilder<'_> { + OneofDescriptorProtoBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + name_written: false, + options_written: false, + } + } + + pub fn name(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_written = true; + Ok(self) + } + + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(2, value)?; + self.options_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &OneofDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedOneofDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedOneofDescriptorProto { + type Reader<'a> = OneofDescriptorProto<'a>; + fn reader(&self) -> OneofDescriptorProto<'_> { + OneofDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedOneofDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedOneofDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct EnumDescriptorProto<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn value(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn reserved_range(&self) -> roto_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) -> roto_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) -> roto_runtime::Result { + let offset = self.visibility_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn visibility_or_default(&self) -> roto_runtime::Result { + self.visibility().or(Ok(0)) + } + + pub fn has_visibility(&self) -> bool { self.visibility_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct EnumDescriptorProtoBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_written = true; + Ok(self) + } + + pub fn value(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(2, value)?; + self.value_written = true; + Ok(self) + } + + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(3, value)?; + self.options_written = true; + Ok(self) + } + + pub fn reserved_range(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(4, value)?; + self.reserved_range_written = true; + Ok(self) + } + + pub fn reserved_name(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(5, value)?; + self.reserved_name_written = true; + Ok(self) + } + + pub fn visibility(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(6, value)?; + self.visibility_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedEnumDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumDescriptorProto { + type Reader<'a> = EnumDescriptorProto<'a>; + fn reader(&self) -> EnumDescriptorProto<'_> { + EnumDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEnumDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub mod enum_descriptor_proto { +pub struct EnumReservedRange<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + start_offset: Option, + end_offset: Option, +} + +impl<'a> EnumReservedRange<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.start_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn start_or_default(&self) -> roto_runtime::Result { + self.start().or(Ok(0)) + } + + pub fn has_start(&self) -> bool { self.start_offset.is_some() } + + pub fn end(&self) -> roto_runtime::Result { + let offset = self.end_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } + + pub fn has_end(&self) -> bool { self.end_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct EnumReservedRangeBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + start_written: bool, + end_written: bool, +} + +impl<'b> EnumReservedRangeBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> EnumReservedRangeBuilder<'_> { + EnumReservedRangeBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + start_written: false, + end_written: false, + } + } + + pub fn start(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.start_written = true; + Ok(self) + } + + pub fn end(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(2, value)?; + self.end_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumReservedRange<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedEnumReservedRange { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumReservedRange { + type Reader<'a> = EnumReservedRange<'a>; + fn reader(&self) -> EnumReservedRange<'_> { + EnumReservedRange::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumReservedRange { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEnumReservedRange { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +} + +pub struct EnumValueDescriptorProto<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + name_offset: Option, + number_offset: Option, + options_offset: Option, +} + +impl<'a> EnumValueDescriptorProto<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn number(&self) -> roto_runtime::Result { + let offset = self.number_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn number_or_default(&self) -> roto_runtime::Result { + self.number().or(Ok(0)) + } + + pub fn has_number(&self) -> bool { self.number_offset.is_some() } + + pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct EnumValueDescriptorProtoBuilder<'b> { + builder: roto_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: roto_runtime::ProtoBuilder::new(buf), + name_written: false, + number_written: false, + options_written: false, + } + } + + pub fn name(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_written = true; + Ok(self) + } + + pub fn number(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(2, value)?; + self.number_written = true; + Ok(self) + } + + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(3, value)?; + self.options_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumValueDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedEnumValueDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumValueDescriptorProto { + type Reader<'a> = EnumValueDescriptorProto<'a>; + fn reader(&self) -> EnumValueDescriptorProto<'_> { + EnumValueDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumValueDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEnumValueDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct ServiceDescriptorProto<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn method(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct ServiceDescriptorProtoBuilder<'b> { + builder: roto_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: roto_runtime::ProtoBuilder::new(buf), + name_written: false, + method_written: false, + options_written: false, + } + } + + pub fn name(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_written = true; + Ok(self) + } + + pub fn method(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(2, value)?; + self.method_written = true; + Ok(self) + } + + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(3, value)?; + self.options_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ServiceDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedServiceDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedServiceDescriptorProto { + type Reader<'a> = ServiceDescriptorProto<'a>; + fn reader(&self) -> ServiceDescriptorProto<'_> { + ServiceDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedServiceDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedServiceDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct MethodDescriptorProto<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name().or(Ok("")) + } + + pub fn has_name(&self) -> bool { self.name_offset.is_some() } + + pub fn input_type(&self) -> roto_runtime::Result<&'a str> { + let offset = self.input_type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn input_type_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.output_type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn output_type_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.options_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) + } + + pub fn has_options(&self) -> bool { self.options_offset.is_some() } + + pub fn client_streaming(&self) -> roto_runtime::Result { + let offset = self.client_streaming_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn client_streaming_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.server_streaming_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn server_streaming_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct MethodDescriptorProtoBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_written = true; + Ok(self) + } + + pub fn input_type(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(2, value)?; + self.input_type_written = true; + Ok(self) + } + + pub fn output_type(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(3, value)?; + self.output_type_written = true; + Ok(self) + } + + pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(4, value)?; + self.options_written = true; + Ok(self) + } + + pub fn client_streaming(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(5, value)?; + self.client_streaming_written = true; + Ok(self) + } + + pub fn server_streaming(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(6, value)?; + self.server_streaming_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &MethodDescriptorProto<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedMethodDescriptorProto { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedMethodDescriptorProto { + type Reader<'a> = MethodDescriptorProto<'a>; + fn reader(&self) -> MethodDescriptorProto<'_> { + MethodDescriptorProto::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedMethodDescriptorProto { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedMethodDescriptorProto { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct FileOptions<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.java_package_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn java_package_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.java_outer_classname_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn java_outer_classname_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.java_multiple_files_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn java_multiple_files_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.java_generate_equals_and_hash_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn java_generate_equals_and_hash_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.java_string_check_utf8_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn java_string_check_utf8_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.optimize_for_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn optimize_for_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.go_package_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn go_package_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.cc_generic_services_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn cc_generic_services_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.java_generic_services_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn java_generic_services_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.py_generic_services_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn py_generic_services_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn cc_enable_arenas(&self) -> roto_runtime::Result { + let offset = self.cc_enable_arenas_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn cc_enable_arenas_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.objc_class_prefix_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn objc_class_prefix_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.csharp_namespace_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn csharp_namespace_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.swift_prefix_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn swift_prefix_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.php_class_prefix_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn php_class_prefix_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.php_namespace_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn php_namespace_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.php_metadata_namespace_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn php_metadata_namespace_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.ruby_package_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn ruby_package_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FileOptionsBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.java_package_written = true; + Ok(self) + } + + pub fn java_outer_classname(mut self, value: &str) -> roto_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) -> roto_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) -> roto_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) -> roto_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) -> roto_runtime::Result { + self.builder.write_varint(9, value)?; + self.optimize_for_written = true; + Ok(self) + } + + pub fn go_package(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(11, value)?; + self.go_package_written = true; + Ok(self) + } + + pub fn cc_generic_services(mut self, value: u64) -> roto_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) -> roto_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) -> roto_runtime::Result { + self.builder.write_varint(18, value)?; + self.py_generic_services_written = true; + Ok(self) + } + + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(23, value)?; + self.deprecated_written = true; + Ok(self) + } + + pub fn cc_enable_arenas(mut self, value: u64) -> roto_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) -> roto_runtime::Result { + self.builder.write_string(36, value)?; + self.objc_class_prefix_written = true; + Ok(self) + } + + pub fn csharp_namespace(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(37, value)?; + self.csharp_namespace_written = true; + Ok(self) + } + + pub fn swift_prefix(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(39, value)?; + self.swift_prefix_written = true; + Ok(self) + } + + pub fn php_class_prefix(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(40, value)?; + self.php_class_prefix_written = true; + Ok(self) + } + + pub fn php_namespace(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(41, value)?; + self.php_namespace_written = true; + Ok(self) + } + + pub fn php_metadata_namespace(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(44, value)?; + self.php_metadata_namespace_written = true; + Ok(self) + } + + pub fn ruby_package(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(45, value)?; + self.ruby_package_written = true; + Ok(self) + } + + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(50, value)?; + self.features_written = true; + Ok(self) + } + + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FileOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFileOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFileOptions { + type Reader<'a> = FileOptions<'a>; + fn reader(&self) -> FileOptions<'_> { + FileOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFileOptions { + fn decode(buf: bytes::Bytes) -> roto_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: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.message_set_wire_format_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn message_set_wire_format_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.no_standard_descriptor_accessor_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn no_standard_descriptor_accessor_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn map_entry(&self) -> roto_runtime::Result { + let offset = self.map_entry_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn map_entry_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_legacy_json_field_conflicts_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_legacy_json_field_conflicts_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct MessageOptionsBuilder<'b> { + builder: roto_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: roto_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) -> roto_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) -> roto_runtime::Result { + self.builder.write_varint(2, value)?; + self.no_standard_descriptor_accessor_written = true; + Ok(self) + } + + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(3, value)?; + self.deprecated_written = true; + Ok(self) + } + + pub fn map_entry(mut self, value: u64) -> roto_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) -> roto_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]) -> roto_runtime::Result { + self.builder.write_bytes(12, value)?; + self.features_written = true; + Ok(self) + } + + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &MessageOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedMessageOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedMessageOptions { + type Reader<'a> = MessageOptions<'a>; + fn reader(&self) -> MessageOptions<'_> { + MessageOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedMessageOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedMessageOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct FieldOptions<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.ctype_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn ctype_or_default(&self) -> roto_runtime::Result { + self.ctype().or(Ok(0)) + } + + pub fn has_ctype(&self) -> bool { self.ctype_offset.is_some() } + + pub fn packed(&self) -> roto_runtime::Result { + let offset = self.packed_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn packed_or_default(&self) -> roto_runtime::Result { + self.packed().or(Ok(false)) + } + + pub fn has_packed(&self) -> bool { self.packed_offset.is_some() } + + pub fn jstype(&self) -> roto_runtime::Result { + let offset = self.jstype_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn jstype_or_default(&self) -> roto_runtime::Result { + self.jstype().or(Ok(0)) + } + + pub fn has_jstype(&self) -> bool { self.jstype_offset.is_some() } + + pub fn lazy(&self) -> roto_runtime::Result { + let offset = self.lazy_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn lazy_or_default(&self) -> roto_runtime::Result { + self.lazy().or(Ok(false)) + } + + pub fn has_lazy(&self) -> bool { self.lazy_offset.is_some() } + + pub fn unverified_lazy(&self) -> roto_runtime::Result { + let offset = self.unverified_lazy_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn unverified_lazy_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn weak(&self) -> roto_runtime::Result { + let offset = self.weak_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn weak_or_default(&self) -> roto_runtime::Result { + self.weak().or(Ok(false)) + } + + pub fn has_weak(&self) -> bool { self.weak_offset.is_some() } + + pub fn debug_redact(&self) -> roto_runtime::Result { + let offset = self.debug_redact_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn debug_redact_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.retention_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn retention_or_default(&self) -> roto_runtime::Result { + self.retention().or(Ok(0)) + } + + pub fn has_retention(&self) -> bool { self.retention_offset.is_some() } + + pub fn targets(&self) -> roto_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) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn feature_support(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.feature_support_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn feature_support_or_default(&self) -> roto_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) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FieldOptionsBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_varint(1, value)?; + self.ctype_written = true; + Ok(self) + } + + pub fn packed(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(2, value)?; + self.packed_written = true; + Ok(self) + } + + pub fn jstype(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(6, value)?; + self.jstype_written = true; + Ok(self) + } + + pub fn lazy(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(5, value)?; + self.lazy_written = true; + Ok(self) + } + + pub fn unverified_lazy(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(15, value)?; + self.unverified_lazy_written = true; + Ok(self) + } + + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(3, value)?; + self.deprecated_written = true; + Ok(self) + } + + pub fn weak(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(10, value)?; + self.weak_written = true; + Ok(self) + } + + pub fn debug_redact(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(16, value)?; + self.debug_redact_written = true; + Ok(self) + } + + pub fn retention(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(17, value)?; + self.retention_written = true; + Ok(self) + } + + pub fn targets(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(19, value)?; + self.targets_written = true; + Ok(self) + } + + pub fn edition_defaults(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(20, value)?; + self.edition_defaults_written = true; + Ok(self) + } + + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(21, value)?; + self.features_written = true; + Ok(self) + } + + pub fn feature_support(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(22, value)?; + self.feature_support_written = true; + Ok(self) + } + + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FieldOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFieldOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFieldOptions { + type Reader<'a> = FieldOptions<'a>; + fn reader(&self) -> FieldOptions<'_> { + FieldOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFieldOptions { + fn decode(buf: bytes::Bytes) -> roto_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: roto_runtime::ProtoAccessor<'a>, + edition_offset: Option, + value_offset: Option, +} + +impl<'a> EditionDefault<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn edition_or_default(&self) -> roto_runtime::Result { + self.edition().or(Ok(0)) + } + + pub fn has_edition(&self) -> bool { self.edition_offset.is_some() } + + pub fn value(&self) -> roto_runtime::Result<&'a str> { + let offset = self.value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn value_or_default(&self) -> roto_runtime::Result<&'a str> { + self.value().or(Ok("")) + } + + pub fn has_value(&self) -> bool { self.value_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct EditionDefaultBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + edition_written: bool, + value_written: bool, +} + +impl<'b> EditionDefaultBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> EditionDefaultBuilder<'_> { + EditionDefaultBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + edition_written: false, + value_written: false, + } + } + + pub fn edition(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(3, value)?; + self.edition_written = true; + Ok(self) + } + + pub fn value(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(2, value)?; + self.value_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EditionDefault<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedEditionDefault { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEditionDefault { + type Reader<'a> = EditionDefault<'a>; + fn reader(&self) -> EditionDefault<'_> { + EditionDefault::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEditionDefault { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEditionDefault { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct FeatureSupport<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.edition_introduced_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn edition_introduced_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.edition_deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn edition_deprecated_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.deprecation_warning_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecation_warning_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.edition_removed_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn edition_removed_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.removal_error_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn removal_error_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FeatureSupportBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_varint(1, value)?; + self.edition_introduced_written = true; + Ok(self) + } + + pub fn edition_deprecated(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(2, value)?; + self.edition_deprecated_written = true; + Ok(self) + } + + pub fn deprecation_warning(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(3, value)?; + self.deprecation_warning_written = true; + Ok(self) + } + + pub fn edition_removed(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(4, value)?; + self.edition_removed_written = true; + Ok(self) + } + + pub fn removal_error(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(5, value)?; + self.removal_error_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FeatureSupport<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFeatureSupport { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFeatureSupport { + type Reader<'a> = FeatureSupport<'a>; + fn reader(&self) -> FeatureSupport<'_> { + FeatureSupport::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFeatureSupport { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFeatureSupport { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +} + +pub struct OneofOptions<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + features_offset: Option, + uninterpreted_option_start: Option, + uninterpreted_option_end: Option, +} + +impl<'a> OneofOptions<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct OneofOptionsBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + features_written: bool, + uninterpreted_option_written: bool, +} + +impl<'b> OneofOptionsBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> OneofOptionsBuilder<'_> { + OneofOptionsBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + features_written: false, + uninterpreted_option_written: false, + } + } + + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(1, value)?; + self.features_written = true; + Ok(self) + } + + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &OneofOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedOneofOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedOneofOptions { + type Reader<'a> = OneofOptions<'a>; + fn reader(&self) -> OneofOptions<'_> { + OneofOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedOneofOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedOneofOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct EnumOptions<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.allow_alias_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn allow_alias_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.deprecated_legacy_json_field_conflicts_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_legacy_json_field_conflicts_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct EnumOptionsBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_varint(2, value)?; + self.allow_alias_written = true; + Ok(self) + } + + pub fn deprecated(mut self, value: u64) -> roto_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) -> roto_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]) -> roto_runtime::Result { + self.builder.write_bytes(7, value)?; + self.features_written = true; + Ok(self) + } + + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedEnumOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumOptions { + type Reader<'a> = EnumOptions<'a>; + fn reader(&self) -> EnumOptions<'_> { + EnumOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEnumOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct EnumValueOptions<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn features(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn debug_redact(&self) -> roto_runtime::Result { + let offset = self.debug_redact_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn debug_redact_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.feature_support_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn feature_support_or_default(&self) -> roto_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) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct EnumValueOptionsBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_varint(1, value)?; + self.deprecated_written = true; + Ok(self) + } + + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(2, value)?; + self.features_written = true; + Ok(self) + } + + pub fn debug_redact(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(3, value)?; + self.debug_redact_written = true; + Ok(self) + } + + pub fn feature_support(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(4, value)?; + self.feature_support_written = true; + Ok(self) + } + + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumValueOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedEnumValueOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedEnumValueOptions { + type Reader<'a> = EnumValueOptions<'a>; + fn reader(&self) -> EnumValueOptions<'_> { + EnumValueOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedEnumValueOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedEnumValueOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct ServiceOptions<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn deprecated(&self) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct ServiceOptionsBuilder<'b> { + builder: roto_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: roto_runtime::ProtoBuilder::new(buf), + features_written: false, + deprecated_written: false, + uninterpreted_option_written: false, + } + } + + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(34, value)?; + self.features_written = true; + Ok(self) + } + + pub fn deprecated(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(33, value)?; + self.deprecated_written = true; + Ok(self) + } + + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ServiceOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedServiceOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedServiceOptions { + type Reader<'a> = ServiceOptions<'a>; + fn reader(&self) -> ServiceOptions<'_> { + ServiceOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedServiceOptions { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedServiceOptions { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub struct MethodOptions<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.deprecated_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn deprecated_or_default(&self) -> roto_runtime::Result { + self.deprecated().or(Ok(false)) + } + + pub fn has_deprecated(&self) -> bool { self.deprecated_offset.is_some() } + + pub fn idempotency_level(&self) -> roto_runtime::Result { + let offset = self.idempotency_level_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn idempotency_level_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.features().or(Ok(&[])) + } + + pub fn has_features(&self) -> bool { self.features_offset.is_some() } + + pub fn uninterpreted_option(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct MethodOptionsBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_varint(33, value)?; + self.deprecated_written = true; + Ok(self) + } + + pub fn idempotency_level(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(34, value)?; + self.idempotency_level_written = true; + Ok(self) + } + + pub fn features(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(35, value)?; + self.features_written = true; + Ok(self) + } + + pub fn uninterpreted_option(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &MethodOptions<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedMethodOptions { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedMethodOptions { + type Reader<'a> = MethodOptions<'a>; + fn reader(&self) -> MethodOptions<'_> { + MethodOptions::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedMethodOptions { + fn decode(buf: bytes::Bytes) -> roto_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: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.identifier_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn identifier_value_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.positive_int_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn positive_int_value_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.negative_int_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn negative_int_value_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.double_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(f64::from_le_bytes(bytes.try_into().map_err(|_| roto_runtime::RotoError::WireFormatViolation)?)) + } + + pub fn double_value_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.string_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn string_value_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.aggregate_value_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn aggregate_value_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct UninterpretedOptionBuilder<'b> { + builder: roto_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: roto_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]) -> roto_runtime::Result { + self.builder.write_bytes(2, value)?; + self.name_written = true; + Ok(self) + } + + pub fn identifier_value(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(3, value)?; + self.identifier_value_written = true; + Ok(self) + } + + pub fn positive_int_value(mut self, value: u64) -> roto_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) -> roto_runtime::Result { + self.builder.write_varint(5, value)?; + self.negative_int_value_written = true; + Ok(self) + } + + pub fn double_value(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(6, value)?; + self.double_value_written = true; + Ok(self) + } + + pub fn string_value(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(7, value)?; + self.string_value_written = true; + Ok(self) + } + + pub fn aggregate_value(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(8, value)?; + self.aggregate_value_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &UninterpretedOption<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedUninterpretedOption { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedUninterpretedOption { + type Reader<'a> = UninterpretedOption<'a>; + fn reader(&self) -> UninterpretedOption<'_> { + UninterpretedOption::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedUninterpretedOption { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedUninterpretedOption { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub mod uninterpreted_option { +pub struct NamePart<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + name_part_offset: Option, + is_extension_offset: Option, +} + +impl<'a> NamePart<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.name_part_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn name_part_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.is_extension_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn is_extension_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct NamePartBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + name_part_written: bool, + is_extension_written: bool, +} + +impl<'b> NamePartBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> NamePartBuilder<'_> { + NamePartBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + name_part_written: false, + is_extension_written: false, + } + } + + pub fn name_part(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_part_written = true; + Ok(self) + } + + pub fn is_extension(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(2, value)?; + self.is_extension_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &NamePart<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedNamePart { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedNamePart { + type Reader<'a> = NamePart<'a>; + fn reader(&self) -> NamePart<'_> { + NamePart::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedNamePart { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedNamePart { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +} + +pub struct FeatureSet<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.field_presence_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn field_presence_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.enum_type_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn enum_type_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.repeated_field_encoding_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn repeated_field_encoding_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.utf8_validation_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn utf8_validation_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.message_encoding_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn message_encoding_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.json_format_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn json_format_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.enforce_naming_style_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn enforce_naming_style_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.default_symbol_visibility_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn default_symbol_visibility_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.enforce_proto_limits_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn enforce_proto_limits_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FeatureSetBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_varint(1, value)?; + self.field_presence_written = true; + Ok(self) + } + + pub fn enum_type(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(2, value)?; + self.enum_type_written = true; + Ok(self) + } + + pub fn repeated_field_encoding(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(3, value)?; + self.repeated_field_encoding_written = true; + Ok(self) + } + + pub fn utf8_validation(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(4, value)?; + self.utf8_validation_written = true; + Ok(self) + } + + pub fn message_encoding(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(5, value)?; + self.message_encoding_written = true; + Ok(self) + } + + pub fn json_format(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(6, value)?; + self.json_format_written = true; + Ok(self) + } + + pub fn enforce_naming_style(mut self, value: u64) -> roto_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) -> roto_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) -> roto_runtime::Result { + self.builder.write_varint(9, value)?; + self.enforce_proto_limits_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FeatureSet<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFeatureSet { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFeatureSet { + type Reader<'a> = FeatureSet<'a>; + fn reader(&self) -> FeatureSet<'_> { + FeatureSet::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFeatureSet { + fn decode(buf: bytes::Bytes) -> roto_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: roto_runtime::ProtoAccessor<'a>, +} + +impl<'a> VisibilityFeature<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; + for item in accessor.fields() { + let (offset, tag, _) = item?; + } + + Ok(Self { + accessor, + }) + } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct VisibilityFeatureBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, +} + +impl<'b> VisibilityFeatureBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> VisibilityFeatureBuilder<'_> { + VisibilityFeatureBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + } + } + + pub fn with(mut self, msg: &VisibilityFeature<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedVisibilityFeature { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedVisibilityFeature { + type Reader<'a> = VisibilityFeature<'a>; + fn reader(&self) -> VisibilityFeature<'_> { + VisibilityFeature::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedVisibilityFeature { + fn decode(buf: bytes::Bytes) -> roto_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: roto_runtime::ProtoAccessor<'a>, +} + +impl<'a> ProtoLimitsFeature<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_runtime::ProtoAccessor::new(data)?; + for item in accessor.fields() { + let (offset, tag, _) = item?; + } + + Ok(Self { + accessor, + }) + } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct ProtoLimitsFeatureBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, +} + +impl<'b> ProtoLimitsFeatureBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> ProtoLimitsFeatureBuilder<'_> { + ProtoLimitsFeatureBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + } + } + + pub fn with(mut self, msg: &ProtoLimitsFeature<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedProtoLimitsFeature { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedProtoLimitsFeature { + type Reader<'a> = ProtoLimitsFeature<'a>; + fn reader(&self) -> ProtoLimitsFeature<'_> { + ProtoLimitsFeature::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedProtoLimitsFeature { + fn decode(buf: bytes::Bytes) -> roto_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: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_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) -> roto_runtime::Result { + let offset = self.minimum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn minimum_edition_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.maximum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn maximum_edition_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FeatureSetDefaultsBuilder<'b> { + builder: roto_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: roto_runtime::ProtoBuilder::new(buf), + defaults_written: false, + minimum_edition_written: false, + maximum_edition_written: false, + } + } + + pub fn defaults(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(1, value)?; + self.defaults_written = true; + Ok(self) + } + + pub fn minimum_edition(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(4, value)?; + self.minimum_edition_written = true; + Ok(self) + } + + pub fn maximum_edition(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(5, value)?; + self.maximum_edition_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FeatureSetDefaults<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFeatureSetDefaults { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFeatureSetDefaults { + type Reader<'a> = FeatureSetDefaults<'a>; + fn reader(&self) -> FeatureSetDefaults<'_> { + FeatureSetDefaults::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFeatureSetDefaults { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFeatureSetDefaults { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub mod feature_set_defaults { +pub struct FeatureSetEditionDefault<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + edition_offset: Option, + overridable_features_offset: Option, + fixed_features_offset: Option, +} + +impl<'a> FeatureSetEditionDefault<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_runtime::Result { + let offset = self.edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn edition_or_default(&self) -> roto_runtime::Result { + self.edition().or(Ok(0)) + } + + pub fn has_edition(&self) -> bool { self.edition_offset.is_some() } + + pub fn overridable_features(&self) -> roto_runtime::Result<&'a [u8]> { + let offset = self.overridable_features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn overridable_features_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a [u8]> { + let offset = self.fixed_features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + Ok(bytes) + } + + pub fn fixed_features_or_default(&self) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct FeatureSetEditionDefaultBuilder<'b> { + builder: roto_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: roto_runtime::ProtoBuilder::new(buf), + edition_written: false, + overridable_features_written: false, + fixed_features_written: false, + } + } + + pub fn edition(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(3, value)?; + self.edition_written = true; + Ok(self) + } + + pub fn overridable_features(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(4, value)?; + self.overridable_features_written = true; + Ok(self) + } + + pub fn fixed_features(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(5, value)?; + self.fixed_features_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FeatureSetEditionDefault<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedFeatureSetEditionDefault { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedFeatureSetEditionDefault { + type Reader<'a> = FeatureSetEditionDefault<'a>; + fn reader(&self) -> FeatureSetEditionDefault<'_> { + FeatureSetEditionDefault::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedFeatureSetEditionDefault { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedFeatureSetEditionDefault { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +} + +pub struct SourceCodeInfo<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + location_start: Option, + location_end: Option, +} + +impl<'a> SourceCodeInfo<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct SourceCodeInfoBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + location_written: bool, +} + +impl<'b> SourceCodeInfoBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> SourceCodeInfoBuilder<'_> { + SourceCodeInfoBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + location_written: false, + } + } + + pub fn location(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(1, value)?; + self.location_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &SourceCodeInfo<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedSourceCodeInfo { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedSourceCodeInfo { + type Reader<'a> = SourceCodeInfo<'a>; + fn reader(&self) -> SourceCodeInfo<'_> { + SourceCodeInfo::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedSourceCodeInfo { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedSourceCodeInfo { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub mod source_code_info { +pub struct Location<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_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) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.leading_comments_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn leading_comments_or_default(&self) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.trailing_comments_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn trailing_comments_or_default(&self) -> roto_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) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct LocationBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.path_written = true; + Ok(self) + } + + pub fn span(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(2, value)?; + self.span_written = true; + Ok(self) + } + + pub fn leading_comments(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(3, value)?; + self.leading_comments_written = true; + Ok(self) + } + + pub fn trailing_comments(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(4, value)?; + self.trailing_comments_written = true; + Ok(self) + } + + pub fn leading_detached_comments(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(6, value)?; + self.leading_detached_comments_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Location<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedLocation { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedLocation { + type Reader<'a> = Location<'a>; + fn reader(&self) -> Location<'_> { + Location::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedLocation { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedLocation { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +} + +pub struct GeneratedCodeInfo<'a> { + accessor: roto_runtime::ProtoAccessor<'a>, + annotation_start: Option, + annotation_end: Option, +} + +impl<'a> GeneratedCodeInfo<'a> { + pub fn new(data: &'a [u8]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_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) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct GeneratedCodeInfoBuilder<'b> { + builder: roto_runtime::ProtoBuilder<'b>, + annotation_written: bool, +} + +impl<'b> GeneratedCodeInfoBuilder<'b> { + pub fn builder(buf: &mut [u8]) -> GeneratedCodeInfoBuilder<'_> { + GeneratedCodeInfoBuilder { + builder: roto_runtime::ProtoBuilder::new(buf), + annotation_written: false, + } + } + + pub fn annotation(mut self, value: &[u8]) -> roto_runtime::Result { + self.builder.write_bytes(1, value)?; + self.annotation_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &GeneratedCodeInfo<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedGeneratedCodeInfo { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedGeneratedCodeInfo { + type Reader<'a> = GeneratedCodeInfo<'a>; + fn reader(&self) -> GeneratedCodeInfo<'_> { + GeneratedCodeInfo::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedGeneratedCodeInfo { + fn decode(buf: bytes::Bytes) -> roto_runtime::Result { + Ok(OwnedGeneratedCodeInfo { data: buf }) + } + + fn bytes(&self) -> bytes::Bytes { + self.data.clone() + } +} + +pub mod generated_code_info { +pub struct Annotation<'a> { + accessor: roto_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]) -> roto_runtime::Result { + let accessor = roto_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) -> roto_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) -> roto_runtime::Result<&'a str> { + let offset = self.source_file_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + core::str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn source_file_or_default(&self) -> roto_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) -> roto_runtime::Result { + let offset = self.begin_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn begin_or_default(&self) -> roto_runtime::Result { + self.begin().or(Ok(0)) + } + + pub fn has_begin(&self) -> bool { self.begin_offset.is_some() } + + pub fn end(&self) -> roto_runtime::Result { + let offset = self.end_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } + + pub fn has_end(&self) -> bool { self.end_offset.is_some() } + + pub fn semantic(&self) -> roto_runtime::Result { + let offset = self.semantic_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; + let (bytes, _) = self.accessor.get_value_at(offset)?; + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) + } + + pub fn semantic_or_default(&self) -> roto_runtime::Result { + self.semantic().or(Ok(0)) + } + + pub fn has_semantic(&self) -> bool { self.semantic_offset.is_some() } + + pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + +} + +pub struct AnnotationBuilder<'b> { + builder: roto_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: roto_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) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.path_written = true; + Ok(self) + } + + pub fn source_file(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(2, value)?; + self.source_file_written = true; + Ok(self) + } + + pub fn begin(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(3, value)?; + self.begin_written = true; + Ok(self) + } + + pub fn end(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(4, value)?; + self.end_written = true; + Ok(self) + } + + pub fn semantic(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(5, value)?; + self.semantic_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Annotation<'_>) -> roto_runtime::Result { + for item in msg.accessor.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) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +#[cfg(feature = "alloc")] +pub struct OwnedAnnotation { + pub data: bytes::Bytes, +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoOwned for OwnedAnnotation { + type Reader<'a> = Annotation<'a>; + fn reader(&self) -> Annotation<'_> { + Annotation::new(&self.data).expect("failed to create reader") + } +} + +#[cfg(feature = "alloc")] +impl roto_runtime::RotoMessage for OwnedAnnotation { + fn decode(buf: bytes::Bytes) -> roto_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, + } + } +} + +} + +} + + +