From 17ab0d1670f089ba9fef0661bd66f4612c531d01 Mon Sep 17 00:00:00 2001 From: charles Date: Mon, 11 May 2026 17:43:56 -0700 Subject: [PATCH] Update generated protobuf code --- .../src/google/protobuf/compiler/plugin.rs | 557 +- codegen/src/google/protobuf/descriptor.rs | 5723 +++++++++-------- 2 files changed, 3155 insertions(+), 3125 deletions(-) diff --git a/codegen/src/google/protobuf/compiler/plugin.rs b/codegen/src/google/protobuf/compiler/plugin.rs index c6421ec..4a2213a 100644 --- a/codegen/src/google/protobuf/compiler/plugin.rs +++ b/codegen/src/google/protobuf/compiler/plugin.rs @@ -1,9 +1,7 @@ // @generated by protoc-gen-roto — do not edit #![allow(unused_imports)] -use roto_runtime::{ - ProtoAccessor, ProtoBuilder, RepeatedFieldIterator, Result, RotoError, read_varint, -}; +use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator}; use std::str; use crate::google::protobuf::descriptor; @@ -25,70 +23,73 @@ impl<'a> Version<'a> { 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); - } + 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, +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 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) + 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 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) + 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 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) + 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 offset = self.suffix_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) } + 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> { @@ -182,41 +183,28 @@ impl<'a> CodeGeneratorRequest<'a> { 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); - } + 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 == 2 { parameter_offset = Some(offset); } if tag.field_number == 15 { - if proto_file_start.is_none() { - proto_file_start = Some(offset); - } + 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); - } + 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); - } + 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, +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, }) } @@ -228,13 +216,17 @@ impl<'a> CodeGeneratorRequest<'a> { } pub fn parameter(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .parameter_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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(|_| 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), @@ -243,26 +235,28 @@ impl<'a> CodeGeneratorRequest<'a> { } pub fn source_file_descriptors(&self) -> roto_runtime::RepeatedFieldIterator<'a> { - match ( - self.source_file_descriptors_start, - self.source_file_descriptors_end, - ) { + 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 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> { @@ -360,75 +354,74 @@ impl<'a> CodeGeneratorResponse<'a> { 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 == 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); - } + 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, +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 offset = self.error_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) } - 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 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 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) + roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - 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 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), @@ -439,6 +432,7 @@ impl<'a> CodeGeneratorResponse<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct CodeGeneratorResponseBuilder<'b> { @@ -516,164 +510,175 @@ impl<'b> CodeGeneratorResponseBuilder<'b> { } pub mod code_generator_response { - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum Feature { - FEATURENONE = 0, - FEATUREPROTO3OPTIONAL = 1, - FEATURESUPPORTSEDITIONS = 2, - } +#[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)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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) -> 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.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() +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)?; + 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)?; + 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)?; + 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.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() + } +} + +} + diff --git a/codegen/src/google/protobuf/descriptor.rs b/codegen/src/google/protobuf/descriptor.rs index 24ff708..5ca11a4 100644 --- a/codegen/src/google/protobuf/descriptor.rs +++ b/codegen/src/google/protobuf/descriptor.rs @@ -1,11 +1,10 @@ // @generated by protoc-gen-roto — do not edit #![allow(unused_imports)] -use roto_runtime::{ - ProtoAccessor, ProtoBuilder, RepeatedFieldIterator, Result, RotoError, read_varint, -}; +use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator}; use std::str; + #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(i32)] pub enum Edition { @@ -80,17 +79,14 @@ impl<'a> FileDescriptorSet<'a> { for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { - if file_start.is_none() { - file_start = Some(offset); - } + if file_start.is_none() { file_start = Some(offset); } file_end = Some(offset); } } Ok(Self { accessor, - file_start, - file_end, +file_start, file_end, }) } @@ -104,6 +100,7 @@ impl<'a> FileDescriptorSet<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct FileDescriptorSetBuilder<'b> { @@ -197,117 +194,89 @@ impl<'a> FileDescriptorProto<'a> { 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 == 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); - } + 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); - } + 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); - } + 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); - } + 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); - } + 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); - } + 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); - } + 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); - } + 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); - } + 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, +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 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) } + 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 offset = self.package_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) } + 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), @@ -365,42 +334,57 @@ impl<'a> FileDescriptorProto<'a> { } pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .options_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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 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 offset = self.syntax_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) } - 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 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> { @@ -605,97 +589,71 @@ impl<'a> DescriptorProto<'a> { 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 == 1 { name_offset = Some(offset); } if tag.field_number == 2 { - if field_start.is_none() { - field_start = Some(offset); - } + 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); - } + 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); - } + 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); - } + 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); - } + 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); - } + 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 == 7 { options_offset = Some(offset); } if tag.field_number == 9 { - if reserved_range_start.is_none() { - reserved_range_start = Some(offset); - } + 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); - } + 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); - } + 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, +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 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) } + 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), @@ -739,13 +697,17 @@ impl<'a> DescriptorProto<'a> { } pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .options_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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), @@ -761,18 +723,21 @@ impl<'a> DescriptorProto<'a> { } pub fn visibility(&self) -> roto_runtime::Result { - let offset = self - .visibility_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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) + 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> { @@ -904,228 +869,233 @@ impl<'b> DescriptorProtoBuilder<'b> { } pub mod descriptor_proto { - pub struct ExtensionRange<'a> { - accessor: roto_runtime::ProtoAccessor<'a>, - start_offset: Option, - end_offset: Option, - options_offset: Option, +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, + }) } - 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); - } - } + 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) + } - Ok(Self { - accessor, - start_offset, - end_offset, - options_offset, - }) - } + pub fn start_or_default(&self) -> roto_runtime::Result { + self.start().or(Ok(0)) + } - 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 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(&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 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 end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } - pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { - self.accessor.raw_fields() + 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 struct ExtensionRangeBuilder<'b> { - builder: roto_runtime::ProtoBuilder<'b>, - start_written: bool, - end_written: bool, - options_written: bool, + pub fn start(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.start_written = true; + Ok(self) } - 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 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.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 start(mut self, value: i32) -> roto_runtime::Result { - self.builder.write_int32(1, value)?; - self.start_written = true; - Ok(self) + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +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); } } - pub fn end(mut self, value: i32) -> roto_runtime::Result { - self.builder.write_int32(2, value)?; - self.end_written = true; - Ok(self) - } + Ok(Self { + accessor, +start_offset, +end_offset, + }) + } - pub fn options(mut self, value: &[u8]) -> roto_runtime::Result { - self.builder.write_bytes(3, value)?; - self.options_written = true; - Ok(self) - } + 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 with(mut self, msg: &ExtensionRange<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { - let (field_number, raw_bytes) = item?; - let is_written = match field_number { - 1 => self.start_written, - 2 => self.end_written, - 3 => self.options_written, - _ => false, - }; - if !is_written { - self.builder.write_raw(raw_bytes)?; - } - } - Ok(self) - } + pub fn start_or_default(&self) -> roto_runtime::Result { + self.start().or(Ok(0)) + } - pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { - self.builder.finish() + 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 struct ReservedRange<'a> { - accessor: roto_runtime::ProtoAccessor<'a>, - start_offset: Option, - end_offset: Option, + pub fn start(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.start_written = true; + Ok(self) } - 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 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 raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { - self.accessor.raw_fields() - } + pub fn end(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(2, value)?; + self.end_written = true; + Ok(self) } - 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 with(mut self, msg: &ReservedRange<'_>) -> roto_runtime::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.start_written, + 2 => self.end_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; } } - - 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.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() - } + Ok(self) } + + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + } pub struct ExtensionRangeOptions<'a> { @@ -1150,41 +1120,28 @@ impl<'a> ExtensionRangeOptions<'a> { 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); - } + 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); - } + 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); - } + 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, +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, - ) { + 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), } @@ -1198,26 +1155,33 @@ impl<'a> ExtensionRangeOptions<'a> { } pub fn features(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .features_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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) -> 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 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> { @@ -1286,193 +1250,199 @@ impl<'b> ExtensionRangeOptionsBuilder<'b> { } pub mod extension_range_options { - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum VerificationState { - DECLARATION = 0, - UNVERIFIED = 1, +#[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, + }) } - impl VerificationState { - pub fn from_i32(value: i32) -> Self { - match value { - 0 => VerificationState::DECLARATION, - 1 => VerificationState::UNVERIFIED, - _ => VerificationState::DECLARATION, + 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)?; + 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)?; + 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.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 struct Declaration<'a> { - accessor: roto_runtime::ProtoAccessor<'a>, - number_offset: Option, - full_name_offset: Option, - type_offset: Option, - reserved_offset: Option, - repeated_offset: Option, + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() } +} - 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 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(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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 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 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.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() - } - } } pub struct FieldDescriptorProto<'a> { @@ -1506,158 +1476,171 @@ impl<'a> FieldDescriptorProto<'a> { 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); - } + 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, +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 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) } + 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 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) + 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 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) + 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 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) + 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 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(|_| 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 offset = self.extendee_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) } + 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 offset = self.default_value_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) } + 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 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) + 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 offset = self.json_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) } + 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 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) -> 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 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> { @@ -1789,77 +1772,78 @@ impl<'b> FieldDescriptorProtoBuilder<'b> { } 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, - } +#[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, - } +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, - } +#[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, - } +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, @@ -1873,40 +1857,45 @@ impl<'a> OneofDescriptorProto<'a> { 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); - } + 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, +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 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) } + 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 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> { @@ -1983,57 +1972,46 @@ impl<'a> EnumDescriptorProto<'a> { 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 == 1 { name_offset = Some(offset); } if tag.field_number == 2 { - if value_start.is_none() { - value_start = Some(offset); - } + 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 == 3 { options_offset = Some(offset); } if tag.field_number == 4 { - if reserved_range_start.is_none() { - reserved_range_start = Some(offset); - } + 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); - } + 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); - } + 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, +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 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) } + 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), @@ -2042,13 +2020,17 @@ impl<'a> EnumDescriptorProto<'a> { } pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .options_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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), @@ -2064,18 +2046,21 @@ impl<'a> EnumDescriptorProto<'a> { } pub fn visibility(&self) -> roto_runtime::Result { - let offset = self - .visibility_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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) + 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> { @@ -2162,105 +2147,107 @@ impl<'b> EnumDescriptorProtoBuilder<'b> { } pub mod enum_descriptor_proto { - pub struct EnumReservedRange<'a> { - accessor: roto_runtime::ProtoAccessor<'a>, - start_offset: Option, - end_offset: Option, +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, + }) } - 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); - } - } + 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) + } - Ok(Self { - accessor, - start_offset, - end_offset, - }) - } + pub fn start_or_default(&self) -> roto_runtime::Result { + self.start().or(Ok(0)) + } - 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 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(&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 raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { - self.accessor.raw_fields() + 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 struct EnumReservedRangeBuilder<'b> { - builder: roto_runtime::ProtoBuilder<'b>, - start_written: bool, - end_written: bool, + pub fn start(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.start_written = true; + Ok(self) } - 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 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.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)?; } } - - 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.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() - } + Ok(self) } + + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + } pub struct EnumValueDescriptorProto<'a> { @@ -2278,54 +2265,59 @@ impl<'a> EnumValueDescriptorProto<'a> { 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); - } + 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, +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 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) } - 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 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 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> { @@ -2401,37 +2393,34 @@ impl<'a> ServiceDescriptorProto<'a> { 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 == 1 { name_offset = Some(offset); } if tag.field_number == 2 { - if method_start.is_none() { - method_start = Some(offset); - } + if method_start.is_none() { method_start = Some(offset); } method_end = Some(offset); } - if tag.field_number == 3 { - options_offset = Some(offset); - } + if tag.field_number == 3 { options_offset = Some(offset); } } Ok(Self { accessor, - name_offset, - method_start, - method_end, - options_offset, +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 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) } + 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), @@ -2440,16 +2429,21 @@ impl<'a> ServiceDescriptorProto<'a> { } pub fn options(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .options_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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> { @@ -2529,92 +2523,101 @@ impl<'a> MethodDescriptorProto<'a> { 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); - } + 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, +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 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) } + 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 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(|_| 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 offset = self.output_type_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) } + 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 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) -> 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 options_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.options().or(Ok(&[])) } - pub fn server_streaming(&self) -> roto_runtime::Result { - let offset = self - .server_streaming_offset - .ok_or(roto_runtime::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)?; - 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 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> { @@ -2753,284 +2756,300 @@ impl<'a> FileOptions<'a> { 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 == 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); - } + 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, +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 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(|_| 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 offset = self.java_outer_classname_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) } + 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 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) + 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 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) + 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 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) + 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 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) + 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 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(|_| 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 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) + 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 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) + 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 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) + 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 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) + 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 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) + 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 offset = self.objc_class_prefix_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) } + 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 offset = self.csharp_namespace_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) } + 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 offset = self.swift_prefix_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) } + 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 offset = self.php_class_prefix_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) } + 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 offset = self.php_namespace_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) } + 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 offset = self.php_metadata_namespace_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) } + 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 offset = self.ruby_package_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) } + 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 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, - ) { + 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), } @@ -3039,6 +3058,7 @@ impl<'a> FileOptions<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct FileOptionsBuilder<'b> { @@ -3260,27 +3280,28 @@ impl<'b> FileOptionsBuilder<'b> { } pub mod file_options { - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum OptimizeMode { - SPEED = 1, - CODESIZE = 2, - LITERUNTIME = 3, - Unknown = 0, - } +#[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, - } +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, @@ -3306,108 +3327,104 @@ impl<'a> MessageOptions<'a> { 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 == 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); - } + 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, +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 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) + 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 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) + 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 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) + 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 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) + 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 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) + 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 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, - ) { + 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), } @@ -3416,6 +3433,7 @@ impl<'a> MessageOptions<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct MessageOptionsBuilder<'b> { @@ -3467,10 +3485,7 @@ impl<'b> MessageOptionsBuilder<'b> { Ok(self) } - pub fn deprecated_legacy_json_field_conflicts( - mut self, - value: u64, - ) -> roto_runtime::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) @@ -3556,171 +3571,158 @@ impl<'a> FieldOptions<'a> { 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 == 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); - } + 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); - } + 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 == 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); - } + 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, +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 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) + 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 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) + 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 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) + 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 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) + 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 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) + 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 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) + 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 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) + 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 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) + roto_runtime::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - 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 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), @@ -3736,26 +3738,31 @@ impl<'a> FieldOptions<'a> { } pub fn features(&self) -> roto_runtime::Result<&'a [u8]> { - let offset = self - .features_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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 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, - ) { + 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), } @@ -3764,6 +3771,7 @@ impl<'a> FieldOptions<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct FieldOptionsBuilder<'b> { @@ -3922,364 +3930,373 @@ impl<'b> FieldOptionsBuilder<'b> { } pub mod field_options { - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum CType { - STRING = 0, - CORD = 1, - STRINGPIECE = 2, +#[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, + }) } - impl CType { - pub fn from_i32(value: i32) -> Self { - match value { - 0 => CType::STRING, - 1 => CType::CORD, - 2 => CType::STRINGPIECE, - _ => CType::STRING, + 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)?; + 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.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) } - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum JSType { - JSNORMAL = 0, - JSSTRING = 1, - JSNUMBER = 2, + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +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, + }) } - impl JSType { - pub fn from_i32(value: i32) -> Self { - match value { - 0 => JSType::JSNORMAL, - 1 => JSType::JSSTRING, - 2 => JSType::JSNUMBER, - _ => JSType::JSNORMAL, + 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)?; + 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)?; + 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.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) } - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum OptionRetention { - RETENTIONUNKNOWN = 0, - RETENTIONRUNTIME = 1, - RETENTIONSOURCE = 2, + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() } +} - 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 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)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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.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() - } - } - - 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_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 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(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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 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)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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.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() - } - } } pub struct OneofOptions<'a> { @@ -4297,38 +4314,34 @@ impl<'a> OneofOptions<'a> { 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 == 1 { features_offset = Some(offset); } if tag.field_number == 999 { - if uninterpreted_option_start.is_none() { - uninterpreted_option_start = Some(offset); - } + 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, +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 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, - ) { + 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), } @@ -4337,6 +4350,7 @@ impl<'a> OneofOptions<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct OneofOptionsBuilder<'b> { @@ -4407,80 +4421,76 @@ impl<'a> EnumOptions<'a> { 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 == 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); - } + 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, +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 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) + 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 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) + 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 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) + 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 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, - ) { + 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), } @@ -4489,6 +4499,7 @@ impl<'a> EnumOptions<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct EnumOptionsBuilder<'b> { @@ -4524,10 +4535,7 @@ impl<'b> EnumOptionsBuilder<'b> { Ok(self) } - pub fn deprecated_legacy_json_field_conflicts( - mut self, - value: u64, - ) -> roto_runtime::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) @@ -4589,78 +4597,76 @@ impl<'a> EnumValueOptions<'a> { 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 == 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); - } + 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, +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 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) + 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 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 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) + 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 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, - ) { + 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), } @@ -4669,6 +4675,7 @@ impl<'a> EnumValueOptions<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct EnumValueOptionsBuilder<'b> { @@ -4762,52 +4769,48 @@ impl<'a> ServiceOptions<'a> { 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 == 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); - } + 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, +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 offset = self.features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?; let (bytes, _) = self.accessor.get_value_at(offset)?; Ok(bytes) } - 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 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, - ) { + 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), } @@ -4816,6 +4819,7 @@ impl<'a> ServiceOptions<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct ServiceOptionsBuilder<'b> { @@ -4893,66 +4897,62 @@ impl<'a> MethodOptions<'a> { 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 == 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); - } + 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, +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 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) + 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 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) + 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 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, - ) { + 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), } @@ -4961,6 +4961,7 @@ impl<'a> MethodOptions<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct MethodOptionsBuilder<'b> { @@ -5029,26 +5030,27 @@ impl<'b> MethodOptionsBuilder<'b> { } pub mod method_options { - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum IdempotencyLevel { - IDEMPOTENCYUNKNOWN = 0, - NOSIDEEFFECTS = 1, - IDEMPOTENT = 2, - } +#[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, - } +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, @@ -5075,41 +5077,26 @@ impl<'a> UninterpretedOption<'a> { for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 2 { - if name_start.is_none() { - name_start = Some(offset); - } + 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); - } + 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, +name_start, name_end, +identifier_value_offset, +positive_int_value_offset, +negative_int_value_offset, +double_value_offset, +string_value_offset, +aggregate_value_offset, }) } @@ -5121,62 +5108,81 @@ impl<'a> UninterpretedOption<'a> { } pub fn identifier_value(&self) -> roto_runtime::Result<&'a str> { - let offset = self - .identifier_value_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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(|_| roto_runtime::RotoError::WireFormatViolation) } - 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 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 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) + 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 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 - })?)) + 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 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 offset = self.aggregate_value_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) } + 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> { @@ -5272,103 +5278,107 @@ impl<'b> UninterpretedOptionBuilder<'b> { } pub mod uninterpreted_option { - pub struct NamePart<'a> { - accessor: roto_runtime::ProtoAccessor<'a>, - name_part_offset: Option, - is_extension_offset: 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, + }) } - 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); - } - } + 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(|_| roto_runtime::RotoError::WireFormatViolation) + } - Ok(Self { - accessor, - name_part_offset, - is_extension_offset, - }) - } + pub fn name_part_or_default(&self) -> roto_runtime::Result<&'a str> { + self.name_part().or(Ok("")) + } - 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(|_| roto_runtime::RotoError::WireFormatViolation) - } + 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(&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 raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { - self.accessor.raw_fields() + 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 struct NamePartBuilder<'b> { - builder: roto_runtime::ProtoBuilder<'b>, - name_part_written: bool, - is_extension_written: bool, + pub fn name_part(mut self, value: &str) -> roto_runtime::Result { + self.builder.write_string(1, value)?; + self.name_part_written = true; + Ok(self) } - 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 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.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)?; } } - - 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.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() - } + Ok(self) } + + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + } pub struct FeatureSet<'a> { @@ -5398,142 +5408,143 @@ impl<'a> FeatureSet<'a> { 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); - } + 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, +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 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) + 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 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) + 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 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) + 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 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) + 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 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) + 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 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) + 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 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) + 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 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) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - 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 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> { @@ -5647,276 +5658,293 @@ impl<'b> FeatureSetBuilder<'b> { } pub mod feature_set { - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum FieldPresence { - FIELDPRESENCEUNKNOWN = 0, - EXPLICIT = 1, - IMPLICIT = 2, - LEGACYREQUIRED = 3, +#[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, + }) } - 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, + 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.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) } - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum EnumType { - ENUMTYPEUNKNOWN = 0, - OPEN = 1, - CLOSED = 2, + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + +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, + }) } - impl EnumType { - pub fn from_i32(value: i32) -> Self { - match value { - 0 => EnumType::ENUMTYPEUNKNOWN, - 1 => EnumType::OPEN, - 2 => EnumType::CLOSED, - _ => EnumType::ENUMTYPEUNKNOWN, + 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.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) } - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum RepeatedFieldEncoding { - REPEATEDFIELDENCODINGUNKNOWN = 0, - PACKED = 1, - EXPANDED = 2, + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() } +} - impl RepeatedFieldEncoding { - pub fn from_i32(value: i32) -> Self { - match value { - 0 => RepeatedFieldEncoding::REPEATEDFIELDENCODINGUNKNOWN, - 1 => RepeatedFieldEncoding::PACKED, - 2 => RepeatedFieldEncoding::EXPANDED, - _ => RepeatedFieldEncoding::REPEATEDFIELDENCODINGUNKNOWN, - } +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, } } +} - #[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)?; - 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.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() - } - } - - 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)?; - 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.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() - } - } - - 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> { @@ -5937,25 +5965,18 @@ impl<'a> FeatureSetDefaults<'a> { for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { - if defaults_start.is_none() { - defaults_start = Some(offset); - } + 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); - } + 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, +defaults_start, defaults_end, +minimum_edition_offset, +maximum_edition_offset, }) } @@ -5967,28 +5988,33 @@ impl<'a> FeatureSetDefaults<'a> { } pub fn minimum_edition(&self) -> roto_runtime::Result { - let offset = self - .minimum_edition_offset - .ok_or(roto_runtime::RotoError::FieldNotFound)?; + 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) + roto_runtime::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| roto_runtime::RotoError::WireFormatViolation) } - 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 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> { @@ -6048,126 +6074,132 @@ impl<'b> FeatureSetDefaultsBuilder<'b> { } 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, +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, + }) } - 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); - } - } + 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) + } - Ok(Self { - accessor, - edition_offset, - overridable_features_offset, - fixed_features_offset, - }) - } + pub fn edition_or_default(&self) -> roto_runtime::Result { + self.edition().or(Ok(0)) + } - 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 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(&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) -> 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 overridable_features_or_default(&self) -> roto_runtime::Result<&'a [u8]> { + self.overridable_features().or(Ok(&[])) + } - pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { - self.accessor.raw_fields() + 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 struct FeatureSetEditionDefaultBuilder<'b> { - builder: roto_runtime::ProtoBuilder<'b>, - edition_written: bool, - overridable_features_written: bool, - fixed_features_written: bool, + pub fn edition(mut self, value: u64) -> roto_runtime::Result { + self.builder.write_varint(3, value)?; + self.edition_written = true; + Ok(self) } - 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 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.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)?; } } - - 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.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() - } + Ok(self) } + + pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { + self.builder.finish() + } +} + } pub struct SourceCodeInfo<'a> { @@ -6184,17 +6216,14 @@ impl<'a> SourceCodeInfo<'a> { for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { - if location_start.is_none() { - location_start = Some(offset); - } + if location_start.is_none() { location_start = Some(offset); } location_end = Some(offset); } } Ok(Self { accessor, - location_start, - location_end, +location_start, location_end, }) } @@ -6208,6 +6237,7 @@ impl<'a> SourceCodeInfo<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct SourceCodeInfoBuilder<'b> { @@ -6249,188 +6279,182 @@ impl<'b> SourceCodeInfoBuilder<'b> { } 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, +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, + }) } - 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)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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 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 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.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() + 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)?; + 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)?; + 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.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() + } +} + } pub struct GeneratedCodeInfo<'a> { @@ -6447,17 +6471,14 @@ impl<'a> GeneratedCodeInfo<'a> { for item in accessor.fields() { let (offset, tag, _) = item?; if tag.field_number == 1 { - if annotation_start.is_none() { - annotation_start = Some(offset); - } + if annotation_start.is_none() { annotation_start = Some(offset); } annotation_end = Some(offset); } } Ok(Self { accessor, - annotation_start, - annotation_end, +annotation_start, annotation_end, }) } @@ -6471,6 +6492,7 @@ impl<'a> GeneratedCodeInfo<'a> { pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { self.accessor.raw_fields() } + } pub struct GeneratedCodeInfoBuilder<'b> { @@ -6512,200 +6534,203 @@ impl<'b> GeneratedCodeInfoBuilder<'b> { } 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, +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, + }) } - 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)?; - str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation) - } - - 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 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 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 raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> { - self.accessor.raw_fields() + 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 struct AnnotationBuilder<'b> { - builder: roto_runtime::ProtoBuilder<'b>, - path_written: bool, - source_file_written: bool, - begin_written: bool, - end_written: bool, - semantic_written: bool, + 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(|_| roto_runtime::RotoError::WireFormatViolation) } - 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 source_file_or_default(&self) -> roto_runtime::Result<&'a str> { + self.source_file().or(Ok("")) + } - pub fn path(mut self, value: i32) -> roto_runtime::Result { - self.builder.write_int32(1, value)?; - self.path_written = true; - Ok(self) - } + pub fn has_source_file(&self) -> bool { self.source_file_offset.is_some() } - 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(&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(mut self, value: i32) -> roto_runtime::Result { - self.builder.write_int32(3, value)?; - self.begin_written = true; - Ok(self) - } + pub fn begin_or_default(&self) -> roto_runtime::Result { + self.begin().or(Ok(0)) + } - pub fn end(mut self, value: i32) -> roto_runtime::Result { - self.builder.write_int32(4, value)?; - self.end_written = true; - Ok(self) - } + pub fn has_begin(&self) -> bool { self.begin_offset.is_some() } - pub fn semantic(mut self, value: u64) -> roto_runtime::Result { - self.builder.write_varint(5, value)?; - self.semantic_written = true; - Ok(self) - } + 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 with(mut self, msg: &Annotation<'_>) -> roto_runtime::Result { - for item in msg.raw_fields() { - let (field_number, raw_bytes) = item?; - let is_written = match field_number { - 1 => self.path_written, - 2 => self.source_file_written, - 3 => self.begin_written, - 4 => self.end_written, - 5 => self.semantic_written, - _ => false, - }; - if !is_written { - self.builder.write_raw(raw_bytes)?; - } - } - Ok(self) - } + pub fn end_or_default(&self) -> roto_runtime::Result { + self.end().or(Ok(0)) + } - pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> { - self.builder.finish() + 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 mod annotation { - #[derive(Debug, Clone, Copy, PartialEq, Eq)] - #[repr(i32)] - pub enum Semantic { - NONE = 0, - SET = 1, - ALIAS = 2, - } + pub fn path(mut self, value: i32) -> roto_runtime::Result { + self.builder.write_int32(1, value)?; + self.path_written = true; + Ok(self) + } - impl Semantic { - pub fn from_i32(value: i32) -> Self { - match value { - 0 => Semantic::NONE, - 1 => Semantic::SET, - 2 => Semantic::ALIAS, - _ => Semantic::NONE, - } + 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.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() + } +} + +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, + } } } + +} + +} +