Add Builder::with for updating messages

Allow creating a new message based on an existing one, overriding
specific fields while copying the remaining original fields.

README.md

@@ -95,6 +95,23 @@ fn build_proto(buf: &mut [u8]) -> roto::Result<&[u8]> {
 Builder methods consume `self` and return `Result<Self>`, 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)>`.

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!(

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> {
         self.builder.write_int32(1, value)?;
+        self.major_written = true;
         Ok(self)
     }
 
     pub fn minor(mut self, value: i32) -> crate::Result<Self> {
         self.builder.write_int32(2, value)?;
+        self.minor_written = true;
         Ok(self)
     }
 
     pub fn patch(mut self, value: i32) -> crate::Result<Self> {
         self.builder.write_int32(3, value)?;
+        self.patch_written = true;
         Ok(self)
     }
 
     pub fn suffix(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(4, value)?;
+        self.suffix_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &Version<'_>) -> crate::Result<Self> {
+        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> {
         self.builder.write_string(1, value)?;
+        self.file_to_generate_written = true;
         Ok(self)
     }
 
     pub fn parameter(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(2, value)?;
+        self.parameter_written = true;
         Ok(self)
     }
 
     pub fn proto_file(mut self, value: &[u8]) -> crate::Result<Self> {
         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> {
         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> {
         self.builder.write_bytes(3, value)?;
+        self.compiler_version_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &CodeGeneratorRequest<'_>) -> crate::Result<Self> {
+        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> {
         self.builder.write_string(1, value)?;
+        self.error_written = true;
         Ok(self)
     }
 
     pub fn supported_features(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(2, value)?;
+        self.supported_features_written = true;
         Ok(self)
     }
 
     pub fn minimum_edition(mut self, value: i32) -> crate::Result<Self> {
         self.builder.write_int32(3, value)?;
+        self.minimum_edition_written = true;
         Ok(self)
     }
 
     pub fn maximum_edition(mut self, value: i32) -> crate::Result<Self> {
         self.builder.write_int32(4, value)?;
+        self.maximum_edition_written = true;
         Ok(self)
     }
 
     pub fn file(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(15, value)?;
+        self.file_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &CodeGeneratorResponse<'_>) -> crate::Result<Self> {
+        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> {
         self.builder.write_string(1, value)?;
+        self.name_written = true;
         Ok(self)
     }
 
     pub fn insertion_point(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(2, value)?;
+        self.insertion_point_written = true;
         Ok(self)
     }
 
     pub fn content(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(15, value)?;
+        self.content_written = true;
         Ok(self)
     }
 
     pub fn generated_code_info(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(16, value)?;
+        self.generated_code_info_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &File<'_>) -> crate::Result<Self> {
+        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> {
 }
 
 }
+

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> {
         self.builder.write_string(1, value)?;
+        self.name_written = true;
         Ok(self)
     }
 
     pub fn version(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(2, value)?;
+        self.version_written = true;
         Ok(self)
     }
 
     pub fn payload(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(3, value)?;
+        self.payload_written = true;
         Ok(self)
     }
 
     pub fn is_active(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(4, value)?;
+        self.is_active_written = true;
         Ok(self)
     }
 
     pub fn exploit_count(mut self, value: i32) -> crate::Result<Self> {
         self.builder.write_int32(5, value)?;
+        self.exploit_count_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &Tool<'_>) -> crate::Result<Self> {
+        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> {
         self.builder.write_string(1, value)?;
+        self.host_written = true;
         Ok(self)
     }
 
     pub fn port(mut self, value: i32) -> crate::Result<Self> {
         self.builder.write_int32(2, value)?;
+        self.port_written = true;
         Ok(self)
     }
 
     pub fn encrypted(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(3, value)?;
+        self.encrypted_written = true;
         Ok(self)
     }
 
     pub fn bandwidth_bps(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(4, value)?;
+        self.bandwidth_bps_written = true;
         Ok(self)
     }
 
     pub fn session_key(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(5, value)?;
+        self.session_key_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &Connection<'_>) -> crate::Result<Self> {
+        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> {
         self.builder.write_string(1, value)?;
+        self.handle_written = true;
         Ok(self)
     }
 
     pub fn real_name(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(2, value)?;
+        self.real_name_written = true;
         Ok(self)
     }
 
     pub fn age(mut self, value: i32) -> crate::Result<Self> {
         self.builder.write_int32(3, value)?;
+        self.age_written = true;
         Ok(self)
     }
 
     pub fn skill_level(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(4, value)?;
+        self.skill_level_written = true;
         Ok(self)
     }
 
     pub fn is_elite(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(5, value)?;
+        self.is_elite_written = true;
         Ok(self)
     }
 
     pub fn crew_id(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(6, value)?;
+        self.crew_id_written = true;
         Ok(self)
     }
 
     pub fn exploits(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(7, value)?;
+        self.exploits_written = true;
         Ok(self)
     }
 
     pub fn tools(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(8, value)?;
+        self.tools_written = true;
         Ok(self)
     }
 
     pub fn active_connection(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(9, value)?;
+        self.active_connection_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &Hacker<'_>) -> crate::Result<Self> {
+        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> {
         self.builder.write_string(1, value)?;
+        self.name_written = true;
         Ok(self)
     }
 
     pub fn variant(mut self, value: i32) -> crate::Result<Self> {
         self.builder.write_int32(2, value)?;
+        self.variant_written = true;
         Ok(self)
     }
 
     pub fn size_bytes(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(3, value)?;
+        self.size_bytes_written = true;
         Ok(self)
     }
 
     pub fn payload(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(4, value)?;
+        self.payload_written = true;
         Ok(self)
     }
 
     pub fn polymorphic(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(5, value)?;
+        self.polymorphic_written = true;
         Ok(self)
     }
 
     pub fn targets(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(6, value)?;
+        self.targets_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &Worm<'_>) -> crate::Result<Self> {
+        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> {
         self.builder.write_string(1, value)?;
+        self.codename_written = true;
         Ok(self)
     }
 
     pub fn target_corp(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(2, value)?;
+        self.target_corp_written = true;
         Ok(self)
     }
 
     pub fn timestamp(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(3, value)?;
+        self.timestamp_written = true;
         Ok(self)
     }
 
     pub fn successful(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(4, value)?;
+        self.successful_written = true;
         Ok(self)
     }
 
     pub fn stolen_data(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(5, value)?;
+        self.stolen_data_written = true;
         Ok(self)
     }
 
     pub fn crew(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(6, value)?;
+        self.crew_written = true;
         Ok(self)
     }
 
     pub fn worm(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(7, value)?;
+        self.worm_written = true;
         Ok(self)
     }
 
     pub fn log_entries(mut self, value: &str) -> crate::Result<Self> {
         self.builder.write_string(8, value)?;
+        self.log_entries_written = true;
         Ok(self)
     }
 
     pub fn severity(mut self, value: i32) -> crate::Result<Self> {
         self.builder.write_int32(9, value)?;
+        self.severity_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &Operation<'_>) -> crate::Result<Self> {
+        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> {
         self.builder.write_string(1, value)?;
+        self.name_written = true;
         Ok(self)
     }
 
     pub fn operations(mut self, value: &[u8]) -> crate::Result<Self> {
         self.builder.write_bytes(2, value)?;
+        self.operations_written = true;
         Ok(self)
     }
 
     pub fn total_bytes_stolen(mut self, value: u64) -> crate::Result<Self> {
         self.builder.write_varint(3, value)?;
+        self.total_bytes_stolen_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &Campaign<'_>) -> crate::Result<Self> {
+        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)
     }