diff --git a/README.md b/README.md index 0773c2e..7f99f06 100644 --- a/README.md +++ b/README.md @@ -95,6 +95,23 @@ fn build_proto(buf: &mut [u8]) -> roto::Result<&[u8]> { Builder methods consume `self` and return `Result`, enabling `?`-based chaining. `finish()` returns `Result<&'b mut [u8]>` — a slice of the portion of the buffer that was written. +### Updating messages + +You can read a message, modify specific fields, and use `.with()` to copy the remaining fields from the original binary. + +```rust +fn update_proto(data: &[u8], buf: &mut [u8]) -> roto::Result<&[u8]> { + let msg = Message::new(data)?; + + let mut builder = MessageBuilder::builder(buf); + if msg.foo()? == "bar" { + builder = builder.foo("foosbar")?; + } + + builder.with(&msg)?.finish() +} +``` + ### Repeated fields Repeated fields return a `RepeatedFieldIterator<'a>`. Each item yields `Result<(&[u8], WireType)>`. diff --git a/src/generator.rs b/src/generator.rs index b8d4d47..5d863e7 100644 --- a/src/generator.rs +++ b/src/generator.rs @@ -279,7 +279,7 @@ fn write_message(msg_proto: &DescriptorProto, output: &mut String) { let tag = field_proto.number().unwrap(); let f_type = field_proto.r#type().unwrap() as i32; let (rust_type, method) = map_type_to_rust_builder(f_type); - builder_fields.push((field_name, safe_name, tag, rust_type, method)); + builder_fields.push((field_name, safe_name, tag as u32, rust_type, method)); } // Builder struct — one `_written: bool` flag per field @@ -288,7 +288,7 @@ fn write_message(msg_proto: &DescriptorProto, output: &mut String) { for (field_name, _, _, _, _) in &builder_fields { output.push_str(&format!(" {}_written: bool,\n", field_name)); } - output.push_str(&format!("}}\.\n\nimpl<'b> {}Builder<'b> {{\n", msg_name)); + output.push_str(&format!("}}\n\nimpl<'b> {}Builder<'b> {{\n", msg_name)); // Constructor — initialise every flag to false output.push_str(&format!( diff --git a/src/google/protobuf/compiler/plugin.rs b/src/google/protobuf/compiler/plugin.rs index b36d535..e2fafc5 100644 --- a/src/google/protobuf/compiler/plugin.rs +++ b/src/google/protobuf/compiler/plugin.rs @@ -1,6 +1,9 @@ +// @generated by protoc-gen-roto — do not edit + +use crate::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator}; use std::str; -// use crate::google::protobuf::descriptor; +use crate::google::protobuf::descriptor; pub struct Version<'a> { accessor: crate::ProtoAccessor<'a>, @@ -58,36 +61,69 @@ suffix_offset, str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct VersionBuilder<'b> { builder: crate::ProtoBuilder<'b>, + major_written: bool, + minor_written: bool, + patch_written: bool, + suffix_written: bool, } impl<'b> VersionBuilder<'b> { pub fn builder(buf: &mut [u8]) -> VersionBuilder<'_> { VersionBuilder { builder: crate::ProtoBuilder::new(buf), + major_written: false, + minor_written: false, + patch_written: false, + suffix_written: false, } } pub fn major(mut self, value: i32) -> crate::Result { self.builder.write_int32(1, value)?; + self.major_written = true; Ok(self) } pub fn minor(mut self, value: i32) -> crate::Result { self.builder.write_int32(2, value)?; + self.minor_written = true; Ok(self) } pub fn patch(mut self, value: i32) -> crate::Result { self.builder.write_int32(3, value)?; + self.patch_written = true; Ok(self) } pub fn suffix(mut self, value: &str) -> crate::Result { self.builder.write_string(4, value)?; + self.suffix_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Version<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.major_written, + 2 => self.minor_written, + 3 => self.patch_written, + 4 => self.suffix_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -180,41 +216,78 @@ compiler_version_offset, Ok(bytes) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct CodeGeneratorRequestBuilder<'b> { builder: crate::ProtoBuilder<'b>, + file_to_generate_written: bool, + parameter_written: bool, + proto_file_written: bool, + source_file_descriptors_written: bool, + compiler_version_written: bool, } impl<'b> CodeGeneratorRequestBuilder<'b> { pub fn builder(buf: &mut [u8]) -> CodeGeneratorRequestBuilder<'_> { CodeGeneratorRequestBuilder { builder: crate::ProtoBuilder::new(buf), + file_to_generate_written: false, + parameter_written: false, + proto_file_written: false, + source_file_descriptors_written: false, + compiler_version_written: false, } } pub fn file_to_generate(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.file_to_generate_written = true; Ok(self) } pub fn parameter(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.parameter_written = true; Ok(self) } pub fn proto_file(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(15, value)?; + self.proto_file_written = true; Ok(self) } pub fn source_file_descriptors(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(17, value)?; + self.source_file_descriptors_written = true; Ok(self) } pub fn compiler_version(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(3, value)?; + self.compiler_version_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &CodeGeneratorRequest<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.file_to_generate_written, + 2 => self.parameter_written, + 15 => self.proto_file_written, + 17 => self.source_file_descriptors_written, + 3 => self.compiler_version_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -295,41 +368,78 @@ file_start, file_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct CodeGeneratorResponseBuilder<'b> { builder: crate::ProtoBuilder<'b>, + error_written: bool, + supported_features_written: bool, + minimum_edition_written: bool, + maximum_edition_written: bool, + file_written: bool, } impl<'b> CodeGeneratorResponseBuilder<'b> { pub fn builder(buf: &mut [u8]) -> CodeGeneratorResponseBuilder<'_> { CodeGeneratorResponseBuilder { builder: crate::ProtoBuilder::new(buf), + error_written: false, + supported_features_written: false, + minimum_edition_written: false, + maximum_edition_written: false, + file_written: false, } } pub fn error(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.error_written = true; Ok(self) } pub fn supported_features(mut self, value: u64) -> crate::Result { self.builder.write_varint(2, value)?; + self.supported_features_written = true; Ok(self) } pub fn minimum_edition(mut self, value: i32) -> crate::Result { self.builder.write_int32(3, value)?; + self.minimum_edition_written = true; Ok(self) } pub fn maximum_edition(mut self, value: i32) -> crate::Result { self.builder.write_int32(4, value)?; + self.maximum_edition_written = true; Ok(self) } pub fn file(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(15, value)?; + self.file_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &CodeGeneratorResponse<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.error_written, + 2 => self.supported_features_written, + 3 => self.minimum_edition_written, + 4 => self.maximum_edition_written, + 15 => self.file_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -414,36 +524,69 @@ generated_code_info_offset, Ok(bytes) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FileBuilder<'b> { builder: crate::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: crate::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) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn insertion_point(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.insertion_point_written = true; Ok(self) } pub fn content(mut self, value: &str) -> crate::Result { self.builder.write_string(15, value)?; + self.content_written = true; Ok(self) } pub fn generated_code_info(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(16, value)?; + self.generated_code_info_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &File<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -453,3 +596,4 @@ impl<'b> FileBuilder<'b> { } } + diff --git a/src/google/protobuf/descriptor.rs b/src/google/protobuf/descriptor.rs index e681ee5..98c91d7 100644 --- a/src/google/protobuf/descriptor.rs +++ b/src/google/protobuf/descriptor.rs @@ -1,3 +1,6 @@ +// @generated by protoc-gen-roto — do not edit + +use crate::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator}; use std::str; @@ -93,21 +96,42 @@ file_start, file_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FileDescriptorSetBuilder<'b> { builder: crate::ProtoBuilder<'b>, + file_written: bool, } impl<'b> FileDescriptorSetBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileDescriptorSetBuilder<'_> { FileDescriptorSetBuilder { builder: crate::ProtoBuilder::new(buf), + file_written: false, } } pub fn file(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(1, value)?; + self.file_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FileDescriptorSet<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.file_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -320,86 +344,159 @@ edition_offset, crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FileDescriptorProtoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + package_written: bool, + dependency_written: bool, + public_dependency_written: bool, + weak_dependency_written: bool, + option_dependency_written: bool, + message_type_written: bool, + enum_type_written: bool, + service_written: bool, + extension_written: bool, + options_written: bool, + source_code_info_written: bool, + syntax_written: bool, + edition_written: bool, } impl<'b> FileDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileDescriptorProtoBuilder<'_> { FileDescriptorProtoBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + package_written: false, + dependency_written: false, + public_dependency_written: false, + weak_dependency_written: false, + option_dependency_written: false, + message_type_written: false, + enum_type_written: false, + service_written: false, + extension_written: false, + options_written: false, + source_code_info_written: false, + syntax_written: false, + edition_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn package(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.package_written = true; Ok(self) } pub fn dependency(mut self, value: &str) -> crate::Result { self.builder.write_string(3, value)?; + self.dependency_written = true; Ok(self) } pub fn public_dependency(mut self, value: i32) -> crate::Result { self.builder.write_int32(10, value)?; + self.public_dependency_written = true; Ok(self) } pub fn weak_dependency(mut self, value: i32) -> crate::Result { self.builder.write_int32(11, value)?; + self.weak_dependency_written = true; Ok(self) } pub fn option_dependency(mut self, value: &str) -> crate::Result { self.builder.write_string(15, value)?; + self.option_dependency_written = true; Ok(self) } pub fn message_type(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(4, value)?; + self.message_type_written = true; Ok(self) } pub fn enum_type(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(5, value)?; + self.enum_type_written = true; Ok(self) } pub fn service(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(6, value)?; + self.service_written = true; Ok(self) } pub fn extension(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(7, value)?; + self.extension_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(8, value)?; + self.options_written = true; Ok(self) } pub fn source_code_info(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(9, value)?; + self.source_code_info_written = true; Ok(self) } pub fn syntax(mut self, value: &str) -> crate::Result { self.builder.write_string(12, value)?; + self.syntax_written = true; Ok(self) } pub fn edition(mut self, value: u64) -> crate::Result { self.builder.write_varint(14, value)?; + self.edition_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FileDescriptorProto<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.name_written, + 2 => self.package_written, + 3 => self.dependency_written, + 10 => self.public_dependency_written, + 11 => self.weak_dependency_written, + 15 => self.option_dependency_written, + 4 => self.message_type_written, + 5 => self.enum_type_written, + 6 => self.service_written, + 7 => self.extension_written, + 8 => self.options_written, + 9 => self.source_code_info_written, + 12 => self.syntax_written, + 14 => self.edition_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -582,71 +679,132 @@ visibility_offset, crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct DescriptorProtoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + field_written: bool, + extension_written: bool, + nested_type_written: bool, + enum_type_written: bool, + extension_range_written: bool, + oneof_decl_written: bool, + options_written: bool, + reserved_range_written: bool, + reserved_name_written: bool, + visibility_written: bool, } impl<'b> DescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> DescriptorProtoBuilder<'_> { DescriptorProtoBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + field_written: false, + extension_written: false, + nested_type_written: false, + enum_type_written: false, + extension_range_written: false, + oneof_decl_written: false, + options_written: false, + reserved_range_written: false, + reserved_name_written: false, + visibility_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn field(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(2, value)?; + self.field_written = true; Ok(self) } pub fn extension(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(6, value)?; + self.extension_written = true; Ok(self) } pub fn nested_type(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(3, value)?; + self.nested_type_written = true; Ok(self) } pub fn enum_type(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(4, value)?; + self.enum_type_written = true; Ok(self) } pub fn extension_range(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(5, value)?; + self.extension_range_written = true; Ok(self) } pub fn oneof_decl(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(8, value)?; + self.oneof_decl_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(7, value)?; + self.options_written = true; Ok(self) } pub fn reserved_range(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(9, value)?; + self.reserved_range_written = true; Ok(self) } pub fn reserved_name(mut self, value: &str) -> crate::Result { self.builder.write_string(10, value)?; + self.reserved_name_written = true; Ok(self) } pub fn visibility(mut self, value: u64) -> crate::Result { self.builder.write_varint(11, value)?; + self.visibility_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &DescriptorProto<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.name_written, + 2 => self.field_written, + 6 => self.extension_written, + 3 => self.nested_type_written, + 4 => self.enum_type_written, + 5 => self.extension_range_written, + 8 => self.oneof_decl_written, + 7 => self.options_written, + 9 => self.reserved_range_written, + 10 => self.reserved_name_written, + 11 => self.visibility_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -702,31 +860,60 @@ options_offset, Ok(bytes) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct ExtensionRangeBuilder<'b> { builder: crate::ProtoBuilder<'b>, + start_written: bool, + end_written: bool, + options_written: bool, } impl<'b> ExtensionRangeBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ExtensionRangeBuilder<'_> { ExtensionRangeBuilder { builder: crate::ProtoBuilder::new(buf), + start_written: false, + end_written: false, + options_written: false, } } pub fn start(mut self, value: i32) -> crate::Result { self.builder.write_int32(1, value)?; + self.start_written = true; Ok(self) } pub fn end(mut self, value: i32) -> crate::Result { self.builder.write_int32(2, value)?; + self.end_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(3, value)?; + self.options_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ExtensionRange<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -771,26 +958,51 @@ end_offset, crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct ReservedRangeBuilder<'b> { builder: crate::ProtoBuilder<'b>, + start_written: bool, + end_written: bool, } impl<'b> ReservedRangeBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ReservedRangeBuilder<'_> { ReservedRangeBuilder { builder: crate::ProtoBuilder::new(buf), + start_written: false, + end_written: false, } } pub fn start(mut self, value: i32) -> crate::Result { self.builder.write_int32(1, value)?; + self.start_written = true; Ok(self) } pub fn end(mut self, value: i32) -> crate::Result { self.builder.write_int32(2, value)?; + self.end_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ReservedRange<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -869,36 +1081,69 @@ verification_offset, crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct ExtensionRangeOptionsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + uninterpreted_option_written: bool, + declaration_written: bool, + features_written: bool, + verification_written: bool, } impl<'b> ExtensionRangeOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ExtensionRangeOptionsBuilder<'_> { ExtensionRangeOptionsBuilder { builder: crate::ProtoBuilder::new(buf), + uninterpreted_option_written: false, + declaration_written: false, + features_written: false, + verification_written: false, } } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; Ok(self) } pub fn declaration(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(2, value)?; + self.declaration_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(50, value)?; + self.features_written = true; Ok(self) } pub fn verification(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.verification_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ExtensionRangeOptions<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 999 => self.uninterpreted_option_written, + 2 => self.declaration_written, + 50 => self.features_written, + 3 => self.verification_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -991,41 +1236,78 @@ repeated_offset, crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct DeclarationBuilder<'b> { builder: crate::ProtoBuilder<'b>, + number_written: bool, + full_name_written: bool, + type_written: bool, + reserved_written: bool, + repeated_written: bool, } impl<'b> DeclarationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> DeclarationBuilder<'_> { DeclarationBuilder { builder: crate::ProtoBuilder::new(buf), + number_written: false, + full_name_written: false, + type_written: false, + reserved_written: false, + repeated_written: false, } } pub fn number(mut self, value: i32) -> crate::Result { self.builder.write_int32(1, value)?; + self.number_written = true; Ok(self) } pub fn full_name(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.full_name_written = true; Ok(self) } pub fn r#type(mut self, value: &str) -> crate::Result { self.builder.write_string(3, value)?; + self.type_written = true; Ok(self) } pub fn reserved(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.reserved_written = true; Ok(self) } pub fn repeated(mut self, value: u64) -> crate::Result { self.builder.write_varint(6, value)?; + self.repeated_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Declaration<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -1162,71 +1444,132 @@ proto3_optional_offset, crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FieldDescriptorProtoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + number_written: bool, + label_written: bool, + type_written: bool, + type_name_written: bool, + extendee_written: bool, + default_value_written: bool, + oneof_index_written: bool, + json_name_written: bool, + options_written: bool, + proto3_optional_written: bool, } impl<'b> FieldDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FieldDescriptorProtoBuilder<'_> { FieldDescriptorProtoBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + number_written: false, + label_written: false, + type_written: false, + type_name_written: false, + extendee_written: false, + default_value_written: false, + oneof_index_written: false, + json_name_written: false, + options_written: false, + proto3_optional_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn number(mut self, value: i32) -> crate::Result { self.builder.write_int32(3, value)?; + self.number_written = true; Ok(self) } pub fn label(mut self, value: u64) -> crate::Result { self.builder.write_varint(4, value)?; + self.label_written = true; Ok(self) } pub fn r#type(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.type_written = true; Ok(self) } pub fn type_name(mut self, value: &str) -> crate::Result { self.builder.write_string(6, value)?; + self.type_name_written = true; Ok(self) } pub fn extendee(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.extendee_written = true; Ok(self) } pub fn default_value(mut self, value: &str) -> crate::Result { self.builder.write_string(7, value)?; + self.default_value_written = true; Ok(self) } pub fn oneof_index(mut self, value: i32) -> crate::Result { self.builder.write_int32(9, value)?; + self.oneof_index_written = true; Ok(self) } pub fn json_name(mut self, value: &str) -> crate::Result { self.builder.write_string(10, value)?; + self.json_name_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(8, value)?; + self.options_written = true; Ok(self) } pub fn proto3_optional(mut self, value: u64) -> crate::Result { self.builder.write_varint(17, value)?; + self.proto3_optional_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FieldDescriptorProto<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.name_written, + 3 => self.number_written, + 4 => self.label_written, + 5 => self.type_written, + 6 => self.type_name_written, + 2 => self.extendee_written, + 7 => self.default_value_written, + 9 => self.oneof_index_written, + 10 => self.json_name_written, + 8 => self.options_written, + 17 => self.proto3_optional_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -1344,26 +1687,51 @@ options_offset, Ok(bytes) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct OneofDescriptorProtoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + options_written: bool, } impl<'b> OneofDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> OneofDescriptorProtoBuilder<'_> { OneofDescriptorProtoBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + options_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(2, value)?; + self.options_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &OneofDescriptorProto<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.name_written, + 2 => self.options_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -1466,46 +1834,87 @@ visibility_offset, crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct EnumDescriptorProtoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + value_written: bool, + options_written: bool, + reserved_range_written: bool, + reserved_name_written: bool, + visibility_written: bool, } impl<'b> EnumDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumDescriptorProtoBuilder<'_> { EnumDescriptorProtoBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + value_written: false, + options_written: false, + reserved_range_written: false, + reserved_name_written: false, + visibility_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn value(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(2, value)?; + self.value_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(3, value)?; + self.options_written = true; Ok(self) } pub fn reserved_range(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(4, value)?; + self.reserved_range_written = true; Ok(self) } pub fn reserved_name(mut self, value: &str) -> crate::Result { self.builder.write_string(5, value)?; + self.reserved_name_written = true; Ok(self) } pub fn visibility(mut self, value: u64) -> crate::Result { self.builder.write_varint(6, value)?; + self.visibility_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumDescriptorProto<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.name_written, + 2 => self.value_written, + 3 => self.options_written, + 4 => self.reserved_range_written, + 5 => self.reserved_name_written, + 6 => self.visibility_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -1551,26 +1960,51 @@ end_offset, crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct EnumReservedRangeBuilder<'b> { builder: crate::ProtoBuilder<'b>, + start_written: bool, + end_written: bool, } impl<'b> EnumReservedRangeBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumReservedRangeBuilder<'_> { EnumReservedRangeBuilder { builder: crate::ProtoBuilder::new(buf), + start_written: false, + end_written: false, } } pub fn start(mut self, value: i32) -> crate::Result { self.builder.write_int32(1, value)?; + self.start_written = true; Ok(self) } pub fn end(mut self, value: i32) -> crate::Result { self.builder.write_int32(2, value)?; + self.end_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumReservedRange<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -1627,31 +2061,60 @@ options_offset, Ok(bytes) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct EnumValueDescriptorProtoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + number_written: bool, + options_written: bool, } impl<'b> EnumValueDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumValueDescriptorProtoBuilder<'_> { EnumValueDescriptorProtoBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + number_written: false, + options_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn number(mut self, value: i32) -> crate::Result { self.builder.write_int32(2, value)?; + self.number_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(3, value)?; + self.options_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumValueDescriptorProto<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.name_written, + 2 => self.number_written, + 3 => self.options_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -1712,31 +2175,60 @@ options_offset, Ok(bytes) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct ServiceDescriptorProtoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + method_written: bool, + options_written: bool, } impl<'b> ServiceDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ServiceDescriptorProtoBuilder<'_> { ServiceDescriptorProtoBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + method_written: false, + options_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn method(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(2, value)?; + self.method_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(3, value)?; + self.options_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ServiceDescriptorProto<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.name_written, + 2 => self.method_written, + 3 => self.options_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -1821,46 +2313,87 @@ server_streaming_offset, crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct MethodDescriptorProtoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + input_type_written: bool, + output_type_written: bool, + options_written: bool, + client_streaming_written: bool, + server_streaming_written: bool, } impl<'b> MethodDescriptorProtoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> MethodDescriptorProtoBuilder<'_> { MethodDescriptorProtoBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + input_type_written: false, + output_type_written: false, + options_written: false, + client_streaming_written: false, + server_streaming_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn input_type(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.input_type_written = true; Ok(self) } pub fn output_type(mut self, value: &str) -> crate::Result { self.builder.write_string(3, value)?; + self.output_type_written = true; Ok(self) } pub fn options(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(4, value)?; + self.options_written = true; Ok(self) } pub fn client_streaming(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.client_streaming_written = true; Ok(self) } pub fn server_streaming(mut self, value: u64) -> crate::Result { self.builder.write_varint(6, value)?; + self.server_streaming_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &MethodDescriptorProto<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.name_written, + 2 => self.input_type_written, + 3 => self.output_type_written, + 4 => self.options_written, + 5 => self.client_streaming_written, + 6 => self.server_streaming_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -2101,121 +2634,222 @@ uninterpreted_option_start, uninterpreted_option_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FileOptionsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + java_package_written: bool, + java_outer_classname_written: bool, + java_multiple_files_written: bool, + java_generate_equals_and_hash_written: bool, + java_string_check_utf8_written: bool, + optimize_for_written: bool, + go_package_written: bool, + cc_generic_services_written: bool, + java_generic_services_written: bool, + py_generic_services_written: bool, + deprecated_written: bool, + cc_enable_arenas_written: bool, + objc_class_prefix_written: bool, + csharp_namespace_written: bool, + swift_prefix_written: bool, + php_class_prefix_written: bool, + php_namespace_written: bool, + php_metadata_namespace_written: bool, + ruby_package_written: bool, + features_written: bool, + uninterpreted_option_written: bool, } impl<'b> FileOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FileOptionsBuilder<'_> { FileOptionsBuilder { builder: crate::ProtoBuilder::new(buf), + java_package_written: false, + java_outer_classname_written: false, + java_multiple_files_written: false, + java_generate_equals_and_hash_written: false, + java_string_check_utf8_written: false, + optimize_for_written: false, + go_package_written: false, + cc_generic_services_written: false, + java_generic_services_written: false, + py_generic_services_written: false, + deprecated_written: false, + cc_enable_arenas_written: false, + objc_class_prefix_written: false, + csharp_namespace_written: false, + swift_prefix_written: false, + php_class_prefix_written: false, + php_namespace_written: false, + php_metadata_namespace_written: false, + ruby_package_written: false, + features_written: false, + uninterpreted_option_written: false, } } pub fn java_package(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.java_package_written = true; Ok(self) } pub fn java_outer_classname(mut self, value: &str) -> crate::Result { self.builder.write_string(8, value)?; + self.java_outer_classname_written = true; Ok(self) } pub fn java_multiple_files(mut self, value: u64) -> crate::Result { self.builder.write_varint(10, value)?; + self.java_multiple_files_written = true; Ok(self) } pub fn java_generate_equals_and_hash(mut self, value: u64) -> crate::Result { self.builder.write_varint(20, value)?; + self.java_generate_equals_and_hash_written = true; Ok(self) } pub fn java_string_check_utf8(mut self, value: u64) -> crate::Result { self.builder.write_varint(27, value)?; + self.java_string_check_utf8_written = true; Ok(self) } pub fn optimize_for(mut self, value: u64) -> crate::Result { self.builder.write_varint(9, value)?; + self.optimize_for_written = true; Ok(self) } pub fn go_package(mut self, value: &str) -> crate::Result { self.builder.write_string(11, value)?; + self.go_package_written = true; Ok(self) } pub fn cc_generic_services(mut self, value: u64) -> crate::Result { self.builder.write_varint(16, value)?; + self.cc_generic_services_written = true; Ok(self) } pub fn java_generic_services(mut self, value: u64) -> crate::Result { self.builder.write_varint(17, value)?; + self.java_generic_services_written = true; Ok(self) } pub fn py_generic_services(mut self, value: u64) -> crate::Result { self.builder.write_varint(18, value)?; + self.py_generic_services_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::Result { self.builder.write_varint(23, value)?; + self.deprecated_written = true; Ok(self) } pub fn cc_enable_arenas(mut self, value: u64) -> crate::Result { self.builder.write_varint(31, value)?; + self.cc_enable_arenas_written = true; Ok(self) } pub fn objc_class_prefix(mut self, value: &str) -> crate::Result { self.builder.write_string(36, value)?; + self.objc_class_prefix_written = true; Ok(self) } pub fn csharp_namespace(mut self, value: &str) -> crate::Result { self.builder.write_string(37, value)?; + self.csharp_namespace_written = true; Ok(self) } pub fn swift_prefix(mut self, value: &str) -> crate::Result { self.builder.write_string(39, value)?; + self.swift_prefix_written = true; Ok(self) } pub fn php_class_prefix(mut self, value: &str) -> crate::Result { self.builder.write_string(40, value)?; + self.php_class_prefix_written = true; Ok(self) } pub fn php_namespace(mut self, value: &str) -> crate::Result { self.builder.write_string(41, value)?; + self.php_namespace_written = true; Ok(self) } pub fn php_metadata_namespace(mut self, value: &str) -> crate::Result { self.builder.write_string(44, value)?; + self.php_metadata_namespace_written = true; Ok(self) } pub fn ruby_package(mut self, value: &str) -> crate::Result { self.builder.write_string(45, value)?; + self.ruby_package_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(50, value)?; + self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FileOptions<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.java_package_written, + 8 => self.java_outer_classname_written, + 10 => self.java_multiple_files_written, + 20 => self.java_generate_equals_and_hash_written, + 27 => self.java_string_check_utf8_written, + 9 => self.optimize_for_written, + 11 => self.go_package_written, + 16 => self.cc_generic_services_written, + 17 => self.java_generic_services_written, + 18 => self.py_generic_services_written, + 23 => self.deprecated_written, + 31 => self.cc_enable_arenas_written, + 36 => self.objc_class_prefix_written, + 37 => self.csharp_namespace_written, + 39 => self.swift_prefix_written, + 40 => self.php_class_prefix_written, + 41 => self.php_namespace_written, + 44 => self.php_metadata_namespace_written, + 45 => self.ruby_package_written, + 50 => self.features_written, + 999 => self.uninterpreted_option_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -2339,51 +2973,96 @@ uninterpreted_option_start, uninterpreted_option_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct MessageOptionsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + message_set_wire_format_written: bool, + no_standard_descriptor_accessor_written: bool, + deprecated_written: bool, + map_entry_written: bool, + deprecated_legacy_json_field_conflicts_written: bool, + features_written: bool, + uninterpreted_option_written: bool, } impl<'b> MessageOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> MessageOptionsBuilder<'_> { MessageOptionsBuilder { builder: crate::ProtoBuilder::new(buf), + message_set_wire_format_written: false, + no_standard_descriptor_accessor_written: false, + deprecated_written: false, + map_entry_written: false, + deprecated_legacy_json_field_conflicts_written: false, + features_written: false, + uninterpreted_option_written: false, } } pub fn message_set_wire_format(mut self, value: u64) -> crate::Result { self.builder.write_varint(1, value)?; + self.message_set_wire_format_written = true; Ok(self) } pub fn no_standard_descriptor_accessor(mut self, value: u64) -> crate::Result { self.builder.write_varint(2, value)?; + self.no_standard_descriptor_accessor_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.deprecated_written = true; Ok(self) } pub fn map_entry(mut self, value: u64) -> crate::Result { self.builder.write_varint(7, value)?; + self.map_entry_written = true; Ok(self) } pub fn deprecated_legacy_json_field_conflicts(mut self, value: u64) -> crate::Result { self.builder.write_varint(11, value)?; + self.deprecated_legacy_json_field_conflicts_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(12, value)?; + self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &MessageOptions<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.message_set_wire_format_written, + 2 => self.no_standard_descriptor_accessor_written, + 3 => self.deprecated_written, + 7 => self.map_entry_written, + 11 => self.deprecated_legacy_json_field_conflicts_written, + 12 => self.features_written, + 999 => self.uninterpreted_option_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -2566,86 +3245,159 @@ uninterpreted_option_start, uninterpreted_option_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FieldOptionsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + ctype_written: bool, + packed_written: bool, + jstype_written: bool, + lazy_written: bool, + unverified_lazy_written: bool, + deprecated_written: bool, + weak_written: bool, + debug_redact_written: bool, + retention_written: bool, + targets_written: bool, + edition_defaults_written: bool, + features_written: bool, + feature_support_written: bool, + uninterpreted_option_written: bool, } impl<'b> FieldOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FieldOptionsBuilder<'_> { FieldOptionsBuilder { builder: crate::ProtoBuilder::new(buf), + ctype_written: false, + packed_written: false, + jstype_written: false, + lazy_written: false, + unverified_lazy_written: false, + deprecated_written: false, + weak_written: false, + debug_redact_written: false, + retention_written: false, + targets_written: false, + edition_defaults_written: false, + features_written: false, + feature_support_written: false, + uninterpreted_option_written: false, } } pub fn ctype(mut self, value: u64) -> crate::Result { self.builder.write_varint(1, value)?; + self.ctype_written = true; Ok(self) } pub fn packed(mut self, value: u64) -> crate::Result { self.builder.write_varint(2, value)?; + self.packed_written = true; Ok(self) } pub fn jstype(mut self, value: u64) -> crate::Result { self.builder.write_varint(6, value)?; + self.jstype_written = true; Ok(self) } pub fn lazy(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.lazy_written = true; Ok(self) } pub fn unverified_lazy(mut self, value: u64) -> crate::Result { self.builder.write_varint(15, value)?; + self.unverified_lazy_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.deprecated_written = true; Ok(self) } pub fn weak(mut self, value: u64) -> crate::Result { self.builder.write_varint(10, value)?; + self.weak_written = true; Ok(self) } pub fn debug_redact(mut self, value: u64) -> crate::Result { self.builder.write_varint(16, value)?; + self.debug_redact_written = true; Ok(self) } pub fn retention(mut self, value: u64) -> crate::Result { self.builder.write_varint(17, value)?; + self.retention_written = true; Ok(self) } pub fn targets(mut self, value: u64) -> crate::Result { self.builder.write_varint(19, value)?; + self.targets_written = true; Ok(self) } pub fn edition_defaults(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(20, value)?; + self.edition_defaults_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(21, value)?; + self.features_written = true; Ok(self) } pub fn feature_support(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(22, value)?; + self.feature_support_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FieldOptions<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.ctype_written, + 2 => self.packed_written, + 6 => self.jstype_written, + 5 => self.lazy_written, + 15 => self.unverified_lazy_written, + 3 => self.deprecated_written, + 10 => self.weak_written, + 16 => self.debug_redact_written, + 17 => self.retention_written, + 19 => self.targets_written, + 20 => self.edition_defaults_written, + 21 => self.features_written, + 22 => self.feature_support_written, + 999 => self.uninterpreted_option_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -2781,26 +3533,51 @@ value_offset, str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct EditionDefaultBuilder<'b> { builder: crate::ProtoBuilder<'b>, + edition_written: bool, + value_written: bool, } impl<'b> EditionDefaultBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EditionDefaultBuilder<'_> { EditionDefaultBuilder { builder: crate::ProtoBuilder::new(buf), + edition_written: false, + value_written: false, } } pub fn edition(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.edition_written = true; Ok(self) } pub fn value(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.value_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EditionDefault<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -2875,41 +3652,78 @@ removal_error_offset, str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FeatureSupportBuilder<'b> { builder: crate::ProtoBuilder<'b>, + edition_introduced_written: bool, + edition_deprecated_written: bool, + deprecation_warning_written: bool, + edition_removed_written: bool, + removal_error_written: bool, } impl<'b> FeatureSupportBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSupportBuilder<'_> { FeatureSupportBuilder { builder: crate::ProtoBuilder::new(buf), + edition_introduced_written: false, + edition_deprecated_written: false, + deprecation_warning_written: false, + edition_removed_written: false, + removal_error_written: false, } } pub fn edition_introduced(mut self, value: u64) -> crate::Result { self.builder.write_varint(1, value)?; + self.edition_introduced_written = true; Ok(self) } pub fn edition_deprecated(mut self, value: u64) -> crate::Result { self.builder.write_varint(2, value)?; + self.edition_deprecated_written = true; Ok(self) } pub fn deprecation_warning(mut self, value: &str) -> crate::Result { self.builder.write_string(3, value)?; + self.deprecation_warning_written = true; Ok(self) } pub fn edition_removed(mut self, value: u64) -> crate::Result { self.builder.write_varint(4, value)?; + self.edition_removed_written = true; Ok(self) } pub fn removal_error(mut self, value: &str) -> crate::Result { self.builder.write_string(5, value)?; + self.removal_error_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FeatureSupport<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -2962,26 +3776,51 @@ uninterpreted_option_start, uninterpreted_option_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct OneofOptionsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + features_written: bool, + uninterpreted_option_written: bool, } impl<'b> OneofOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> OneofOptionsBuilder<'_> { OneofOptionsBuilder { builder: crate::ProtoBuilder::new(buf), + features_written: false, + uninterpreted_option_written: false, } } pub fn features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(1, value)?; + self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &OneofOptions<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.features_written, + 999 => self.uninterpreted_option_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -3062,41 +3901,78 @@ uninterpreted_option_start, uninterpreted_option_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct EnumOptionsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + allow_alias_written: bool, + deprecated_written: bool, + deprecated_legacy_json_field_conflicts_written: bool, + features_written: bool, + uninterpreted_option_written: bool, } impl<'b> EnumOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumOptionsBuilder<'_> { EnumOptionsBuilder { builder: crate::ProtoBuilder::new(buf), + allow_alias_written: false, + deprecated_written: false, + deprecated_legacy_json_field_conflicts_written: false, + features_written: false, + uninterpreted_option_written: false, } } pub fn allow_alias(mut self, value: u64) -> crate::Result { self.builder.write_varint(2, value)?; + self.allow_alias_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.deprecated_written = true; Ok(self) } pub fn deprecated_legacy_json_field_conflicts(mut self, value: u64) -> crate::Result { self.builder.write_varint(6, value)?; + self.deprecated_legacy_json_field_conflicts_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(7, value)?; + self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumOptions<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 2 => self.allow_alias_written, + 3 => self.deprecated_written, + 6 => self.deprecated_legacy_json_field_conflicts_written, + 7 => self.features_written, + 999 => self.uninterpreted_option_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -3177,41 +4053,78 @@ uninterpreted_option_start, uninterpreted_option_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct EnumValueOptionsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + deprecated_written: bool, + features_written: bool, + debug_redact_written: bool, + feature_support_written: bool, + uninterpreted_option_written: bool, } impl<'b> EnumValueOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> EnumValueOptionsBuilder<'_> { EnumValueOptionsBuilder { builder: crate::ProtoBuilder::new(buf), + deprecated_written: false, + features_written: false, + debug_redact_written: false, + feature_support_written: false, + uninterpreted_option_written: false, } } pub fn deprecated(mut self, value: u64) -> crate::Result { self.builder.write_varint(1, value)?; + self.deprecated_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(2, value)?; + self.features_written = true; Ok(self) } pub fn debug_redact(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.debug_redact_written = true; Ok(self) } pub fn feature_support(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(4, value)?; + self.feature_support_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &EnumValueOptions<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.deprecated_written, + 2 => self.features_written, + 3 => self.debug_redact_written, + 4 => self.feature_support_written, + 999 => self.uninterpreted_option_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -3272,31 +4185,60 @@ uninterpreted_option_start, uninterpreted_option_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct ServiceOptionsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + features_written: bool, + deprecated_written: bool, + uninterpreted_option_written: bool, } impl<'b> ServiceOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ServiceOptionsBuilder<'_> { ServiceOptionsBuilder { builder: crate::ProtoBuilder::new(buf), + features_written: false, + deprecated_written: false, + uninterpreted_option_written: false, } } pub fn features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(34, value)?; + self.features_written = true; Ok(self) } pub fn deprecated(mut self, value: u64) -> crate::Result { self.builder.write_varint(33, value)?; + self.deprecated_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &ServiceOptions<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 34 => self.features_written, + 33 => self.deprecated_written, + 999 => self.uninterpreted_option_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -3367,36 +4309,69 @@ uninterpreted_option_start, uninterpreted_option_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct MethodOptionsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + deprecated_written: bool, + idempotency_level_written: bool, + features_written: bool, + uninterpreted_option_written: bool, } impl<'b> MethodOptionsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> MethodOptionsBuilder<'_> { MethodOptionsBuilder { builder: crate::ProtoBuilder::new(buf), + deprecated_written: false, + idempotency_level_written: false, + features_written: false, + uninterpreted_option_written: false, } } pub fn deprecated(mut self, value: u64) -> crate::Result { self.builder.write_varint(33, value)?; + self.deprecated_written = true; Ok(self) } pub fn idempotency_level(mut self, value: u64) -> crate::Result { self.builder.write_varint(34, value)?; + self.idempotency_level_written = true; Ok(self) } pub fn features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(35, value)?; + self.features_written = true; Ok(self) } pub fn uninterpreted_option(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(999, value)?; + self.uninterpreted_option_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &MethodOptions<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 33 => self.deprecated_written, + 34 => self.idempotency_level_written, + 35 => self.features_written, + 999 => self.uninterpreted_option_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -3519,51 +4494,96 @@ aggregate_value_offset, str::from_utf8(bytes).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct UninterpretedOptionBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + identifier_value_written: bool, + positive_int_value_written: bool, + negative_int_value_written: bool, + double_value_written: bool, + string_value_written: bool, + aggregate_value_written: bool, } impl<'b> UninterpretedOptionBuilder<'b> { pub fn builder(buf: &mut [u8]) -> UninterpretedOptionBuilder<'_> { UninterpretedOptionBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + identifier_value_written: false, + positive_int_value_written: false, + negative_int_value_written: false, + double_value_written: false, + string_value_written: false, + aggregate_value_written: false, } } pub fn name(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(2, value)?; + self.name_written = true; Ok(self) } pub fn identifier_value(mut self, value: &str) -> crate::Result { self.builder.write_string(3, value)?; + self.identifier_value_written = true; Ok(self) } pub fn positive_int_value(mut self, value: u64) -> crate::Result { self.builder.write_varint(4, value)?; + self.positive_int_value_written = true; Ok(self) } pub fn negative_int_value(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.negative_int_value_written = true; Ok(self) } pub fn double_value(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(6, value)?; + self.double_value_written = true; Ok(self) } pub fn string_value(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(7, value)?; + self.string_value_written = true; Ok(self) } pub fn aggregate_value(mut self, value: &str) -> crate::Result { self.builder.write_string(8, value)?; + self.aggregate_value_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &UninterpretedOption<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 2 => self.name_written, + 3 => self.identifier_value_written, + 4 => self.positive_int_value_written, + 5 => self.negative_int_value_written, + 6 => self.double_value_written, + 7 => self.string_value_written, + 8 => self.aggregate_value_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -3609,26 +4629,51 @@ is_extension_offset, crate::read_varint(bytes).map(|(v, _)| v != 0).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct NamePartBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_part_written: bool, + is_extension_written: bool, } impl<'b> NamePartBuilder<'b> { pub fn builder(buf: &mut [u8]) -> NamePartBuilder<'_> { NamePartBuilder { builder: crate::ProtoBuilder::new(buf), + name_part_written: false, + is_extension_written: false, } } pub fn name_part(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_part_written = true; Ok(self) } pub fn is_extension(mut self, value: u64) -> crate::Result { self.builder.write_varint(2, value)?; + self.is_extension_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &NamePart<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -3745,61 +4790,114 @@ enforce_proto_limits_offset, crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FeatureSetBuilder<'b> { builder: crate::ProtoBuilder<'b>, + field_presence_written: bool, + enum_type_written: bool, + repeated_field_encoding_written: bool, + utf8_validation_written: bool, + message_encoding_written: bool, + json_format_written: bool, + enforce_naming_style_written: bool, + default_symbol_visibility_written: bool, + enforce_proto_limits_written: bool, } impl<'b> FeatureSetBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSetBuilder<'_> { FeatureSetBuilder { builder: crate::ProtoBuilder::new(buf), + field_presence_written: false, + enum_type_written: false, + repeated_field_encoding_written: false, + utf8_validation_written: false, + message_encoding_written: false, + json_format_written: false, + enforce_naming_style_written: false, + default_symbol_visibility_written: false, + enforce_proto_limits_written: false, } } pub fn field_presence(mut self, value: u64) -> crate::Result { self.builder.write_varint(1, value)?; + self.field_presence_written = true; Ok(self) } pub fn enum_type(mut self, value: u64) -> crate::Result { self.builder.write_varint(2, value)?; + self.enum_type_written = true; Ok(self) } pub fn repeated_field_encoding(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.repeated_field_encoding_written = true; Ok(self) } pub fn utf8_validation(mut self, value: u64) -> crate::Result { self.builder.write_varint(4, value)?; + self.utf8_validation_written = true; Ok(self) } pub fn message_encoding(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.message_encoding_written = true; Ok(self) } pub fn json_format(mut self, value: u64) -> crate::Result { self.builder.write_varint(6, value)?; + self.json_format_written = true; Ok(self) } pub fn enforce_naming_style(mut self, value: u64) -> crate::Result { self.builder.write_varint(7, value)?; + self.enforce_naming_style_written = true; Ok(self) } pub fn default_symbol_visibility(mut self, value: u64) -> crate::Result { self.builder.write_varint(8, value)?; + self.default_symbol_visibility_written = true; Ok(self) } pub fn enforce_proto_limits(mut self, value: u64) -> crate::Result { self.builder.write_varint(9, value)?; + self.enforce_proto_limits_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FeatureSet<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.field_presence_written, + 2 => self.enum_type_written, + 3 => self.repeated_field_encoding_written, + 4 => self.utf8_validation_written, + 5 => self.message_encoding_written, + 6 => self.json_format_written, + 7 => self.enforce_naming_style_written, + 8 => self.default_symbol_visibility_written, + 9 => self.enforce_proto_limits_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -3947,21 +5045,21 @@ impl EnforceNamingStyle { } pub struct VisibilityFeature<'a> { - #[allow(dead_code)] accessor: crate::ProtoAccessor<'a>, } impl<'a> VisibilityFeature<'a> { pub fn new(data: &'a [u8]) -> crate::Result { let accessor = crate::ProtoAccessor::new(data)?; - for item in accessor.fields() { - let (_offset, _tag, _) = item?; - } - Ok(Self { accessor, }) } + + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct VisibilityFeatureBuilder<'b> { @@ -3975,6 +5073,19 @@ impl<'b> VisibilityFeatureBuilder<'b> { } } + pub fn with(mut self, msg: &VisibilityFeature<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } + Ok(self) + } + pub fn finish(self) -> crate::Result<&'b mut [u8]> { self.builder.finish() } @@ -4007,21 +5118,21 @@ impl DefaultSymbolVisibility { } pub struct ProtoLimitsFeature<'a> { - #[allow(dead_code)] accessor: crate::ProtoAccessor<'a>, } impl<'a> ProtoLimitsFeature<'a> { pub fn new(data: &'a [u8]) -> crate::Result { let accessor = crate::ProtoAccessor::new(data)?; - for item in accessor.fields() { - let (_offset, _tag, _) = item?; - } - Ok(Self { accessor, }) } + + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct ProtoLimitsFeatureBuilder<'b> { @@ -4035,6 +5146,19 @@ impl<'b> ProtoLimitsFeatureBuilder<'b> { } } + pub fn with(mut self, msg: &ProtoLimitsFeature<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } + Ok(self) + } + pub fn finish(self) -> crate::Result<&'b mut [u8]> { self.builder.finish() } @@ -4116,31 +5240,60 @@ maximum_edition_offset, crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FeatureSetDefaultsBuilder<'b> { builder: crate::ProtoBuilder<'b>, + defaults_written: bool, + minimum_edition_written: bool, + maximum_edition_written: bool, } impl<'b> FeatureSetDefaultsBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSetDefaultsBuilder<'_> { FeatureSetDefaultsBuilder { builder: crate::ProtoBuilder::new(buf), + defaults_written: false, + minimum_edition_written: false, + maximum_edition_written: false, } } pub fn defaults(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(1, value)?; + self.defaults_written = true; Ok(self) } pub fn minimum_edition(mut self, value: u64) -> crate::Result { self.builder.write_varint(4, value)?; + self.minimum_edition_written = true; Ok(self) } pub fn maximum_edition(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.maximum_edition_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FeatureSetDefaults<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.defaults_written, + 4 => self.minimum_edition_written, + 5 => self.maximum_edition_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -4196,31 +5349,60 @@ fixed_features_offset, Ok(bytes) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct FeatureSetEditionDefaultBuilder<'b> { builder: crate::ProtoBuilder<'b>, + edition_written: bool, + overridable_features_written: bool, + fixed_features_written: bool, } impl<'b> FeatureSetEditionDefaultBuilder<'b> { pub fn builder(buf: &mut [u8]) -> FeatureSetEditionDefaultBuilder<'_> { FeatureSetEditionDefaultBuilder { builder: crate::ProtoBuilder::new(buf), + edition_written: false, + overridable_features_written: false, + fixed_features_written: false, } } pub fn edition(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.edition_written = true; Ok(self) } pub fn overridable_features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(4, value)?; + self.overridable_features_written = true; Ok(self) } pub fn fixed_features(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(5, value)?; + self.fixed_features_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &FeatureSetEditionDefault<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -4263,21 +5445,42 @@ location_start, location_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct SourceCodeInfoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + location_written: bool, } impl<'b> SourceCodeInfoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> SourceCodeInfoBuilder<'_> { SourceCodeInfoBuilder { builder: crate::ProtoBuilder::new(buf), + location_written: false, } } pub fn location(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(1, value)?; + self.location_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &SourceCodeInfo<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.location_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -4371,41 +5574,78 @@ leading_detached_comments_start, leading_detached_comments_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct LocationBuilder<'b> { builder: crate::ProtoBuilder<'b>, + path_written: bool, + span_written: bool, + leading_comments_written: bool, + trailing_comments_written: bool, + leading_detached_comments_written: bool, } impl<'b> LocationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> LocationBuilder<'_> { LocationBuilder { builder: crate::ProtoBuilder::new(buf), + path_written: false, + span_written: false, + leading_comments_written: false, + trailing_comments_written: false, + leading_detached_comments_written: false, } } pub fn path(mut self, value: i32) -> crate::Result { self.builder.write_int32(1, value)?; + self.path_written = true; Ok(self) } pub fn span(mut self, value: i32) -> crate::Result { self.builder.write_int32(2, value)?; + self.span_written = true; Ok(self) } pub fn leading_comments(mut self, value: &str) -> crate::Result { self.builder.write_string(3, value)?; + self.leading_comments_written = true; Ok(self) } pub fn trailing_comments(mut self, value: &str) -> crate::Result { self.builder.write_string(4, value)?; + self.trailing_comments_written = true; Ok(self) } pub fn leading_detached_comments(mut self, value: &str) -> crate::Result { self.builder.write_string(6, value)?; + self.leading_detached_comments_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Location<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -4448,21 +5688,42 @@ annotation_start, annotation_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct GeneratedCodeInfoBuilder<'b> { builder: crate::ProtoBuilder<'b>, + annotation_written: bool, } impl<'b> GeneratedCodeInfoBuilder<'b> { pub fn builder(buf: &mut [u8]) -> GeneratedCodeInfoBuilder<'_> { GeneratedCodeInfoBuilder { builder: crate::ProtoBuilder::new(buf), + annotation_written: false, } } pub fn annotation(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(1, value)?; + self.annotation_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &GeneratedCodeInfo<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.annotation_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -4544,41 +5805,78 @@ semantic_offset, crate::read_varint(bytes).map(|(v, _)| v as u64).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct AnnotationBuilder<'b> { builder: crate::ProtoBuilder<'b>, + path_written: bool, + source_file_written: bool, + begin_written: bool, + end_written: bool, + semantic_written: bool, } impl<'b> AnnotationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> AnnotationBuilder<'_> { AnnotationBuilder { builder: crate::ProtoBuilder::new(buf), + path_written: false, + source_file_written: false, + begin_written: false, + end_written: false, + semantic_written: false, } } pub fn path(mut self, value: i32) -> crate::Result { self.builder.write_int32(1, value)?; + self.path_written = true; Ok(self) } pub fn source_file(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.source_file_written = true; Ok(self) } pub fn begin(mut self, value: i32) -> crate::Result { self.builder.write_int32(3, value)?; + self.begin_written = true; Ok(self) } pub fn end(mut self, value: i32) -> crate::Result { self.builder.write_int32(4, value)?; + self.end_written = true; Ok(self) } pub fn semantic(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.semantic_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Annotation<'_>) -> crate::Result { + for item in msg.raw_fields() { + 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) } @@ -4610,3 +5908,4 @@ impl Semantic { } } + diff --git a/src/hackers.rs b/src/hackers.rs index f71e43f..87edbde 100644 --- a/src/hackers.rs +++ b/src/hackers.rs @@ -70,41 +70,78 @@ exploit_count_offset, crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct ToolBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + version_written: bool, + payload_written: bool, + is_active_written: bool, + exploit_count_written: bool, } impl<'b> ToolBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ToolBuilder<'_> { ToolBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + version_written: false, + payload_written: false, + is_active_written: false, + exploit_count_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn version(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.version_written = true; Ok(self) } pub fn payload(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(3, value)?; + self.payload_written = true; Ok(self) } pub fn is_active(mut self, value: u64) -> crate::Result { self.builder.write_varint(4, value)?; + self.is_active_written = true; Ok(self) } pub fn exploit_count(mut self, value: i32) -> crate::Result { self.builder.write_int32(5, value)?; + self.exploit_count_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Tool<'_>) -> crate::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.version_written, + 3 => self.payload_written, + 4 => self.is_active_written, + 5 => self.exploit_count_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -179,41 +216,78 @@ session_key_offset, Ok(bytes) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct ConnectionBuilder<'b> { builder: crate::ProtoBuilder<'b>, + host_written: bool, + port_written: bool, + encrypted_written: bool, + bandwidth_bps_written: bool, + session_key_written: bool, } impl<'b> ConnectionBuilder<'b> { pub fn builder(buf: &mut [u8]) -> ConnectionBuilder<'_> { ConnectionBuilder { builder: crate::ProtoBuilder::new(buf), + host_written: false, + port_written: false, + encrypted_written: false, + bandwidth_bps_written: false, + session_key_written: false, } } pub fn host(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.host_written = true; Ok(self) } pub fn port(mut self, value: i32) -> crate::Result { self.builder.write_int32(2, value)?; + self.port_written = true; Ok(self) } pub fn encrypted(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.encrypted_written = true; Ok(self) } pub fn bandwidth_bps(mut self, value: u64) -> crate::Result { self.builder.write_varint(4, value)?; + self.bandwidth_bps_written = true; Ok(self) } pub fn session_key(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(5, value)?; + self.session_key_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Connection<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.host_written, + 2 => self.port_written, + 3 => self.encrypted_written, + 4 => self.bandwidth_bps_written, + 5 => self.session_key_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -340,61 +414,114 @@ active_connection_offset, Ok(bytes) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct HackerBuilder<'b> { builder: crate::ProtoBuilder<'b>, + handle_written: bool, + real_name_written: bool, + age_written: bool, + skill_level_written: bool, + is_elite_written: bool, + crew_id_written: bool, + exploits_written: bool, + tools_written: bool, + active_connection_written: bool, } impl<'b> HackerBuilder<'b> { pub fn builder(buf: &mut [u8]) -> HackerBuilder<'_> { HackerBuilder { builder: crate::ProtoBuilder::new(buf), + handle_written: false, + real_name_written: false, + age_written: false, + skill_level_written: false, + is_elite_written: false, + crew_id_written: false, + exploits_written: false, + tools_written: false, + active_connection_written: false, } } pub fn handle(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.handle_written = true; Ok(self) } pub fn real_name(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.real_name_written = true; Ok(self) } pub fn age(mut self, value: i32) -> crate::Result { self.builder.write_int32(3, value)?; + self.age_written = true; Ok(self) } pub fn skill_level(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(4, value)?; + self.skill_level_written = true; Ok(self) } pub fn is_elite(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.is_elite_written = true; Ok(self) } pub fn crew_id(mut self, value: u64) -> crate::Result { self.builder.write_varint(6, value)?; + self.crew_id_written = true; Ok(self) } pub fn exploits(mut self, value: &str) -> crate::Result { self.builder.write_string(7, value)?; + self.exploits_written = true; Ok(self) } pub fn tools(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(8, value)?; + self.tools_written = true; Ok(self) } pub fn active_connection(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(9, value)?; + self.active_connection_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Hacker<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.handle_written, + 2 => self.real_name_written, + 3 => self.age_written, + 4 => self.skill_level_written, + 5 => self.is_elite_written, + 6 => self.crew_id_written, + 7 => self.exploits_written, + 8 => self.tools_written, + 9 => self.active_connection_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -485,46 +612,87 @@ targets_start, targets_end, } } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct WormBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + variant_written: bool, + size_bytes_written: bool, + payload_written: bool, + polymorphic_written: bool, + targets_written: bool, } impl<'b> WormBuilder<'b> { pub fn builder(buf: &mut [u8]) -> WormBuilder<'_> { WormBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + variant_written: false, + size_bytes_written: false, + payload_written: false, + polymorphic_written: false, + targets_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn variant(mut self, value: i32) -> crate::Result { self.builder.write_int32(2, value)?; + self.variant_written = true; Ok(self) } pub fn size_bytes(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.size_bytes_written = true; Ok(self) } pub fn payload(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(4, value)?; + self.payload_written = true; Ok(self) } pub fn polymorphic(mut self, value: u64) -> crate::Result { self.builder.write_varint(5, value)?; + self.polymorphic_written = true; Ok(self) } pub fn targets(mut self, value: &str) -> crate::Result { self.builder.write_string(6, value)?; + self.targets_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Worm<'_>) -> crate::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.variant_written, + 3 => self.size_bytes_written, + 4 => self.payload_written, + 5 => self.polymorphic_written, + 6 => self.targets_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -651,61 +819,114 @@ severity_offset, crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct OperationBuilder<'b> { builder: crate::ProtoBuilder<'b>, + codename_written: bool, + target_corp_written: bool, + timestamp_written: bool, + successful_written: bool, + stolen_data_written: bool, + crew_written: bool, + worm_written: bool, + log_entries_written: bool, + severity_written: bool, } impl<'b> OperationBuilder<'b> { pub fn builder(buf: &mut [u8]) -> OperationBuilder<'_> { OperationBuilder { builder: crate::ProtoBuilder::new(buf), + codename_written: false, + target_corp_written: false, + timestamp_written: false, + successful_written: false, + stolen_data_written: false, + crew_written: false, + worm_written: false, + log_entries_written: false, + severity_written: false, } } pub fn codename(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.codename_written = true; Ok(self) } pub fn target_corp(mut self, value: &str) -> crate::Result { self.builder.write_string(2, value)?; + self.target_corp_written = true; Ok(self) } pub fn timestamp(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.timestamp_written = true; Ok(self) } pub fn successful(mut self, value: u64) -> crate::Result { self.builder.write_varint(4, value)?; + self.successful_written = true; Ok(self) } pub fn stolen_data(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(5, value)?; + self.stolen_data_written = true; Ok(self) } pub fn crew(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(6, value)?; + self.crew_written = true; Ok(self) } pub fn worm(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(7, value)?; + self.worm_written = true; Ok(self) } pub fn log_entries(mut self, value: &str) -> crate::Result { self.builder.write_string(8, value)?; + self.log_entries_written = true; Ok(self) } pub fn severity(mut self, value: i32) -> crate::Result { self.builder.write_int32(9, value)?; + self.severity_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Operation<'_>) -> crate::Result { + for item in msg.raw_fields() { + let (field_number, raw_bytes) = item?; + let is_written = match field_number { + 1 => self.codename_written, + 2 => self.target_corp_written, + 3 => self.timestamp_written, + 4 => self.successful_written, + 5 => self.stolen_data_written, + 6 => self.crew_written, + 7 => self.worm_written, + 8 => self.log_entries_written, + 9 => self.severity_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) } @@ -766,31 +987,60 @@ total_bytes_stolen_offset, crate::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| crate::RotoError::WireFormatViolation) } + pub fn raw_fields(&self) -> crate::RawFieldIterator<'a> { + self.accessor.raw_fields() + } + } pub struct CampaignBuilder<'b> { builder: crate::ProtoBuilder<'b>, + name_written: bool, + operations_written: bool, + total_bytes_stolen_written: bool, } impl<'b> CampaignBuilder<'b> { pub fn builder(buf: &mut [u8]) -> CampaignBuilder<'_> { CampaignBuilder { builder: crate::ProtoBuilder::new(buf), + name_written: false, + operations_written: false, + total_bytes_stolen_written: false, } } pub fn name(mut self, value: &str) -> crate::Result { self.builder.write_string(1, value)?; + self.name_written = true; Ok(self) } pub fn operations(mut self, value: &[u8]) -> crate::Result { self.builder.write_bytes(2, value)?; + self.operations_written = true; Ok(self) } pub fn total_bytes_stolen(mut self, value: u64) -> crate::Result { self.builder.write_varint(3, value)?; + self.total_bytes_stolen_written = true; + Ok(self) + } + + pub fn with(mut self, msg: &Campaign<'_>) -> crate::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.operations_written, + 3 => self.total_bytes_stolen_written, + _ => false, + }; + if !is_written { + self.builder.write_raw(raw_bytes)?; + } + } Ok(self) }