Update generated protobuf code

codegen/src/google/protobuf/compiler/plugin.rs

@@ -1,9 +1,7 @@
 // @generated by protoc-gen-roto — do not edit
 #![allow(unused_imports)]
 
-use roto_runtime::{
+use roto_runtime::{ProtoAccessor, ProtoBuilder, Result, RotoError, read_varint, RepeatedFieldIterator};
-    ProtoAccessor, ProtoBuilder, RepeatedFieldIterator, Result, RotoError, read_varint,
-};
 use std::str;
 
 use crate::google::protobuf::descriptor;
@@ -25,70 +23,73 @@ impl<'a> Version<'a> {
         let mut suffix_offset = None;
         for item in accessor.fields() {
             let (offset, tag, _) = item?;
-            if tag.field_number == 1 {
+            if tag.field_number == 1 { major_offset = Some(offset); }
-                major_offset = Some(offset);
+            if tag.field_number == 2 { minor_offset = Some(offset); }
-            }
+            if tag.field_number == 3 { patch_offset = Some(offset); }
-            if tag.field_number == 2 {
+            if tag.field_number == 4 { suffix_offset = Some(offset); }
-                minor_offset = Some(offset);
-            }
-            if tag.field_number == 3 {
-                patch_offset = Some(offset);
-            }
-            if tag.field_number == 4 {
-                suffix_offset = Some(offset);
-            }
         }
 
         Ok(Self {
             accessor,
-            major_offset,
+major_offset,
-            minor_offset,
+minor_offset,
-            patch_offset,
+patch_offset,
-            suffix_offset,
+suffix_offset,
         })
     }
 
     pub fn major(&self) -> roto_runtime::Result<i32> {
-        let offset = self
+        let offset = self.major_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            .major_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
         let (bytes, _) = self.accessor.get_value_at(offset)?;
-        roto_runtime::read_varint(bytes)
+        roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
-            .map(|(v, _)| v as i32)
-            .map_err(|_| roto_runtime::RotoError::WireFormatViolation)
     }
 
+    pub fn major_or_default(&self) -> roto_runtime::Result<i32> {
+        self.major().or(Ok(0))
+    }
+
+    pub fn has_major(&self) -> bool { self.major_offset.is_some() }
+
     pub fn minor(&self) -> roto_runtime::Result<i32> {
-        let offset = self
+        let offset = self.minor_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            .minor_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
         let (bytes, _) = self.accessor.get_value_at(offset)?;
-        roto_runtime::read_varint(bytes)
+        roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
-            .map(|(v, _)| v as i32)
-            .map_err(|_| roto_runtime::RotoError::WireFormatViolation)
     }
 
+    pub fn minor_or_default(&self) -> roto_runtime::Result<i32> {
+        self.minor().or(Ok(0))
+    }
+
+    pub fn has_minor(&self) -> bool { self.minor_offset.is_some() }
+
     pub fn patch(&self) -> roto_runtime::Result<i32> {
-        let offset = self
+        let offset = self.patch_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            .patch_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
         let (bytes, _) = self.accessor.get_value_at(offset)?;
-        roto_runtime::read_varint(bytes)
+        roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
-            .map(|(v, _)| v as i32)
-            .map_err(|_| roto_runtime::RotoError::WireFormatViolation)
     }
 
+    pub fn patch_or_default(&self) -> roto_runtime::Result<i32> {
+        self.patch().or(Ok(0))
+    }
+
+    pub fn has_patch(&self) -> bool { self.patch_offset.is_some() }
+
     pub fn suffix(&self) -> roto_runtime::Result<&'a str> {
-        let offset = self
+        let offset = self.suffix_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            .suffix_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
         let (bytes, _) = self.accessor.get_value_at(offset)?;
         str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
     }
 
+    pub fn suffix_or_default(&self) -> roto_runtime::Result<&'a str> {
+        self.suffix().or(Ok(""))
+    }
+
+    pub fn has_suffix(&self) -> bool { self.suffix_offset.is_some() }
+
     pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> {
         self.accessor.raw_fields()
     }
+
 }
 
 pub struct VersionBuilder<'b> {
@@ -182,41 +183,28 @@ impl<'a> CodeGeneratorRequest<'a> {
         for item in accessor.fields() {
             let (offset, tag, _) = item?;
             if tag.field_number == 1 {
-                if file_to_generate_start.is_none() {
+                if file_to_generate_start.is_none() { file_to_generate_start = Some(offset); }
-                    file_to_generate_start = Some(offset);
-                }
                 file_to_generate_end = Some(offset);
             }
-            if tag.field_number == 2 {
+            if tag.field_number == 2 { parameter_offset = Some(offset); }
-                parameter_offset = Some(offset);
-            }
             if tag.field_number == 15 {
-                if proto_file_start.is_none() {
+                if proto_file_start.is_none() { proto_file_start = Some(offset); }
-                    proto_file_start = Some(offset);
-                }
                 proto_file_end = Some(offset);
             }
             if tag.field_number == 17 {
-                if source_file_descriptors_start.is_none() {
+                if source_file_descriptors_start.is_none() { source_file_descriptors_start = Some(offset); }
-                    source_file_descriptors_start = Some(offset);
-                }
                 source_file_descriptors_end = Some(offset);
             }
-            if tag.field_number == 3 {
+            if tag.field_number == 3 { compiler_version_offset = Some(offset); }
-                compiler_version_offset = Some(offset);
-            }
         }
 
         Ok(Self {
             accessor,
-            file_to_generate_start,
+file_to_generate_start, file_to_generate_end,
-            file_to_generate_end,
+parameter_offset,
-            parameter_offset,
+proto_file_start, proto_file_end,
-            proto_file_start,
+source_file_descriptors_start, source_file_descriptors_end,
-            proto_file_end,
+compiler_version_offset,
-            source_file_descriptors_start,
-            source_file_descriptors_end,
-            compiler_version_offset,
         })
     }
 
@@ -228,13 +216,17 @@ impl<'a> CodeGeneratorRequest<'a> {
     }
 
     pub fn parameter(&self) -> roto_runtime::Result<&'a str> {
-        let offset = self
+        let offset = self.parameter_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            .parameter_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
         let (bytes, _) = self.accessor.get_value_at(offset)?;
         str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
     }
 
+    pub fn parameter_or_default(&self) -> roto_runtime::Result<&'a str> {
+        self.parameter().or(Ok(""))
+    }
+
+    pub fn has_parameter(&self) -> bool { self.parameter_offset.is_some() }
+
     pub fn proto_file(&self) -> roto_runtime::RepeatedFieldIterator<'a> {
         match (self.proto_file_start, self.proto_file_end) {
             (Some(start), Some(end)) => self.accessor.iter_repeated_range(15, start, end),
@@ -243,26 +235,28 @@ impl<'a> CodeGeneratorRequest<'a> {
     }
 
     pub fn source_file_descriptors(&self) -> roto_runtime::RepeatedFieldIterator<'a> {
-        match (
+        match (self.source_file_descriptors_start, self.source_file_descriptors_end) {
-            self.source_file_descriptors_start,
-            self.source_file_descriptors_end,
-        ) {
             (Some(start), Some(end)) => self.accessor.iter_repeated_range(17, start, end),
             _ => self.accessor.iter_repeated(17),
         }
     }
 
     pub fn compiler_version(&self) -> roto_runtime::Result<&'a [u8]> {
-        let offset = self
+        let offset = self.compiler_version_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            .compiler_version_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
         let (bytes, _) = self.accessor.get_value_at(offset)?;
         Ok(bytes)
     }
 
+    pub fn compiler_version_or_default(&self) -> roto_runtime::Result<&'a [u8]> {
+        self.compiler_version().or(Ok(&[]))
+    }
+
+    pub fn has_compiler_version(&self) -> bool { self.compiler_version_offset.is_some() }
+
     pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> {
         self.accessor.raw_fields()
     }
+
 }
 
 pub struct CodeGeneratorRequestBuilder<'b> {
@@ -360,75 +354,74 @@ impl<'a> CodeGeneratorResponse<'a> {
         let mut file_end = None;
         for item in accessor.fields() {
             let (offset, tag, _) = item?;
-            if tag.field_number == 1 {
+            if tag.field_number == 1 { error_offset = Some(offset); }
-                error_offset = Some(offset);
+            if tag.field_number == 2 { supported_features_offset = Some(offset); }
-            }
+            if tag.field_number == 3 { minimum_edition_offset = Some(offset); }
-            if tag.field_number == 2 {
+            if tag.field_number == 4 { maximum_edition_offset = Some(offset); }
-                supported_features_offset = Some(offset);
-            }
-            if tag.field_number == 3 {
-                minimum_edition_offset = Some(offset);
-            }
-            if tag.field_number == 4 {
-                maximum_edition_offset = Some(offset);
-            }
             if tag.field_number == 15 {
-                if file_start.is_none() {
+                if file_start.is_none() { file_start = Some(offset); }
-                    file_start = Some(offset);
-                }
                 file_end = Some(offset);
             }
         }
 
         Ok(Self {
             accessor,
-            error_offset,
+error_offset,
-            supported_features_offset,
+supported_features_offset,
-            minimum_edition_offset,
+minimum_edition_offset,
-            maximum_edition_offset,
+maximum_edition_offset,
-            file_start,
+file_start, file_end,
-            file_end,
         })
     }
 
     pub fn error(&self) -> roto_runtime::Result<&'a str> {
-        let offset = self
+        let offset = self.error_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            .error_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
         let (bytes, _) = self.accessor.get_value_at(offset)?;
         str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
     }
 
-    pub fn supported_features(&self) -> roto_runtime::Result<u32> {
+    pub fn error_or_default(&self) -> roto_runtime::Result<&'a str> {
-        let offset = self
+        self.error().or(Ok(""))
-            .supported_features_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
-        let (bytes, _) = self.accessor.get_value_at(offset)?;
-        roto_runtime::read_varint(bytes)
-            .map(|(v, _)| v as u32)
-            .map_err(|_| roto_runtime::RotoError::WireFormatViolation)
     }
 
+    pub fn has_error(&self) -> bool { self.error_offset.is_some() }
+
+    pub fn supported_features(&self) -> roto_runtime::Result<u32> {
+        let offset = self.supported_features_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
+        let (bytes, _) = self.accessor.get_value_at(offset)?;
+        roto_runtime::read_varint(bytes).map(|(v, _)| v as u32).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
+    }
+
+    pub fn supported_features_or_default(&self) -> roto_runtime::Result<u32> {
+        self.supported_features().or(Ok(0))
+    }
+
+    pub fn has_supported_features(&self) -> bool { self.supported_features_offset.is_some() }
+
     pub fn minimum_edition(&self) -> roto_runtime::Result<i32> {
-        let offset = self
+        let offset = self.minimum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            .minimum_edition_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
         let (bytes, _) = self.accessor.get_value_at(offset)?;
-        roto_runtime::read_varint(bytes)
+        roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
-            .map(|(v, _)| v as i32)
-            .map_err(|_| roto_runtime::RotoError::WireFormatViolation)
     }
 
-    pub fn maximum_edition(&self) -> roto_runtime::Result<i32> {
+    pub fn minimum_edition_or_default(&self) -> roto_runtime::Result<i32> {
-        let offset = self
+        self.minimum_edition().or(Ok(0))
-            .maximum_edition_offset
-            .ok_or(roto_runtime::RotoError::FieldNotFound)?;
-        let (bytes, _) = self.accessor.get_value_at(offset)?;
-        roto_runtime::read_varint(bytes)
-            .map(|(v, _)| v as i32)
-            .map_err(|_| roto_runtime::RotoError::WireFormatViolation)
     }
 
+    pub fn has_minimum_edition(&self) -> bool { self.minimum_edition_offset.is_some() }
+
+    pub fn maximum_edition(&self) -> roto_runtime::Result<i32> {
+        let offset = self.maximum_edition_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
+        let (bytes, _) = self.accessor.get_value_at(offset)?;
+        roto_runtime::read_varint(bytes).map(|(v, _)| v as i32).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
+    }
+
+    pub fn maximum_edition_or_default(&self) -> roto_runtime::Result<i32> {
+        self.maximum_edition().or(Ok(0))
+    }
+
+    pub fn has_maximum_edition(&self) -> bool { self.maximum_edition_offset.is_some() }
+
     pub fn file(&self) -> roto_runtime::RepeatedFieldIterator<'a> {
         match (self.file_start, self.file_end) {
             (Some(start), Some(end)) => self.accessor.iter_repeated_range(15, start, end),
@@ -439,6 +432,7 @@ impl<'a> CodeGeneratorResponse<'a> {
     pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> {
         self.accessor.raw_fields()
     }
+
 }
 
 pub struct CodeGeneratorResponseBuilder<'b> {
@@ -516,164 +510,175 @@ impl<'b> CodeGeneratorResponseBuilder<'b> {
 }
 
 pub mod code_generator_response {
-    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-    #[repr(i32)]
+#[repr(i32)]
-    pub enum Feature {
+pub enum Feature {
-        FEATURENONE = 0,
+    FEATURENONE = 0,
-        FEATUREPROTO3OPTIONAL = 1,
+    FEATUREPROTO3OPTIONAL = 1,
-        FEATURESUPPORTSEDITIONS = 2,
+    FEATURESUPPORTSEDITIONS = 2,
-    }
+}
 
-    impl Feature {
+impl Feature {
-        pub fn from_i32(value: i32) -> Self {
+    pub fn from_i32(value: i32) -> Self {
-            match value {
+        match value {
-                0 => Feature::FEATURENONE,
+            0 => Feature::FEATURENONE,
-                1 => Feature::FEATUREPROTO3OPTIONAL,
+            1 => Feature::FEATUREPROTO3OPTIONAL,
-                2 => Feature::FEATURESUPPORTSEDITIONS,
+            2 => Feature::FEATURESUPPORTSEDITIONS,
-                _ => Feature::FEATURENONE,
+            _ => Feature::FEATURENONE,
-            }
-        }
-    }
-
-    pub struct File<'a> {
-        accessor: roto_runtime::ProtoAccessor<'a>,
-        name_offset: Option<usize>,
-        insertion_point_offset: Option<usize>,
-        content_offset: Option<usize>,
-        generated_code_info_offset: Option<usize>,
-    }
-
-    impl<'a> File<'a> {
-        pub fn new(data: &'a [u8]) -> roto_runtime::Result<Self> {
-            let accessor = roto_runtime::ProtoAccessor::new(data)?;
-            let mut name_offset = None;
-            let mut insertion_point_offset = None;
-            let mut content_offset = None;
-            let mut generated_code_info_offset = None;
-            for item in accessor.fields() {
-                let (offset, tag, _) = item?;
-                if tag.field_number == 1 {
-                    name_offset = Some(offset);
-                }
-                if tag.field_number == 2 {
-                    insertion_point_offset = Some(offset);
-                }
-                if tag.field_number == 15 {
-                    content_offset = Some(offset);
-                }
-                if tag.field_number == 16 {
-                    generated_code_info_offset = Some(offset);
-                }
-            }
-
-            Ok(Self {
-                accessor,
-                name_offset,
-                insertion_point_offset,
-                content_offset,
-                generated_code_info_offset,
-            })
-        }
-
-        pub fn name(&self) -> roto_runtime::Result<&'a str> {
-            let offset = self
-                .name_offset
-                .ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            let (bytes, _) = self.accessor.get_value_at(offset)?;
-            str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
-        }
-
-        pub fn insertion_point(&self) -> roto_runtime::Result<&'a str> {
-            let offset = self
-                .insertion_point_offset
-                .ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            let (bytes, _) = self.accessor.get_value_at(offset)?;
-            str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
-        }
-
-        pub fn content(&self) -> roto_runtime::Result<&'a str> {
-            let offset = self
-                .content_offset
-                .ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            let (bytes, _) = self.accessor.get_value_at(offset)?;
-            str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
-        }
-
-        pub fn generated_code_info(&self) -> roto_runtime::Result<&'a [u8]> {
-            let offset = self
-                .generated_code_info_offset
-                .ok_or(roto_runtime::RotoError::FieldNotFound)?;
-            let (bytes, _) = self.accessor.get_value_at(offset)?;
-            Ok(bytes)
-        }
-
-        pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> {
-            self.accessor.raw_fields()
-        }
-    }
-
-    pub struct FileBuilder<'b> {
-        builder: roto_runtime::ProtoBuilder<'b>,
-        name_written: bool,
-        insertion_point_written: bool,
-        content_written: bool,
-        generated_code_info_written: bool,
-    }
-
-    impl<'b> FileBuilder<'b> {
-        pub fn builder(buf: &mut [u8]) -> FileBuilder<'_> {
-            FileBuilder {
-                builder: roto_runtime::ProtoBuilder::new(buf),
-                name_written: false,
-                insertion_point_written: false,
-                content_written: false,
-                generated_code_info_written: false,
-            }
-        }
-
-        pub fn name(mut self, value: &str) -> roto_runtime::Result<Self> {
-            self.builder.write_string(1, value)?;
-            self.name_written = true;
-            Ok(self)
-        }
-
-        pub fn insertion_point(mut self, value: &str) -> roto_runtime::Result<Self> {
-            self.builder.write_string(2, value)?;
-            self.insertion_point_written = true;
-            Ok(self)
-        }
-
-        pub fn content(mut self, value: &str) -> roto_runtime::Result<Self> {
-            self.builder.write_string(15, value)?;
-            self.content_written = true;
-            Ok(self)
-        }
-
-        pub fn generated_code_info(mut self, value: &[u8]) -> roto_runtime::Result<Self> {
-            self.builder.write_bytes(16, value)?;
-            self.generated_code_info_written = true;
-            Ok(self)
-        }
-
-        pub fn with(mut self, msg: &File<'_>) -> roto_runtime::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)
-        }
-
-        pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> {
-            self.builder.finish()
         }
     }
 }
+
+pub struct File<'a> {
+    accessor: roto_runtime::ProtoAccessor<'a>,
+    name_offset: Option<usize>,
+    insertion_point_offset: Option<usize>,
+    content_offset: Option<usize>,
+    generated_code_info_offset: Option<usize>,
+}
+
+impl<'a> File<'a> {
+    pub fn new(data: &'a [u8]) -> roto_runtime::Result<Self> {
+        let accessor = roto_runtime::ProtoAccessor::new(data)?;
+        let mut name_offset = None;
+        let mut insertion_point_offset = None;
+        let mut content_offset = None;
+        let mut generated_code_info_offset = None;
+        for item in accessor.fields() {
+            let (offset, tag, _) = item?;
+            if tag.field_number == 1 { name_offset = Some(offset); }
+            if tag.field_number == 2 { insertion_point_offset = Some(offset); }
+            if tag.field_number == 15 { content_offset = Some(offset); }
+            if tag.field_number == 16 { generated_code_info_offset = Some(offset); }
+        }
+
+        Ok(Self {
+            accessor,
+name_offset,
+insertion_point_offset,
+content_offset,
+generated_code_info_offset,
+        })
+    }
+
+    pub fn name(&self) -> roto_runtime::Result<&'a str> {
+        let offset = self.name_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
+        let (bytes, _) = self.accessor.get_value_at(offset)?;
+        str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
+    }
+
+    pub fn name_or_default(&self) -> roto_runtime::Result<&'a str> {
+        self.name().or(Ok(""))
+    }
+
+    pub fn has_name(&self) -> bool { self.name_offset.is_some() }
+
+    pub fn insertion_point(&self) -> roto_runtime::Result<&'a str> {
+        let offset = self.insertion_point_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
+        let (bytes, _) = self.accessor.get_value_at(offset)?;
+        str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
+    }
+
+    pub fn insertion_point_or_default(&self) -> roto_runtime::Result<&'a str> {
+        self.insertion_point().or(Ok(""))
+    }
+
+    pub fn has_insertion_point(&self) -> bool { self.insertion_point_offset.is_some() }
+
+    pub fn content(&self) -> roto_runtime::Result<&'a str> {
+        let offset = self.content_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
+        let (bytes, _) = self.accessor.get_value_at(offset)?;
+        str::from_utf8(bytes).map_err(|_| roto_runtime::RotoError::WireFormatViolation)
+    }
+
+    pub fn content_or_default(&self) -> roto_runtime::Result<&'a str> {
+        self.content().or(Ok(""))
+    }
+
+    pub fn has_content(&self) -> bool { self.content_offset.is_some() }
+
+    pub fn generated_code_info(&self) -> roto_runtime::Result<&'a [u8]> {
+        let offset = self.generated_code_info_offset.ok_or(roto_runtime::RotoError::FieldNotFound)?;
+        let (bytes, _) = self.accessor.get_value_at(offset)?;
+        Ok(bytes)
+    }
+
+    pub fn generated_code_info_or_default(&self) -> roto_runtime::Result<&'a [u8]> {
+        self.generated_code_info().or(Ok(&[]))
+    }
+
+    pub fn has_generated_code_info(&self) -> bool { self.generated_code_info_offset.is_some() }
+
+    pub fn raw_fields(&self) -> roto_runtime::RawFieldIterator<'a> {
+        self.accessor.raw_fields()
+    }
+
+}
+
+pub struct FileBuilder<'b> {
+    builder: roto_runtime::ProtoBuilder<'b>,
+    name_written: bool,
+    insertion_point_written: bool,
+    content_written: bool,
+    generated_code_info_written: bool,
+}
+
+impl<'b> FileBuilder<'b> {
+    pub fn builder(buf: &mut [u8]) -> FileBuilder<'_> {
+        FileBuilder {
+            builder: roto_runtime::ProtoBuilder::new(buf),
+            name_written: false,
+            insertion_point_written: false,
+            content_written: false,
+            generated_code_info_written: false,
+        }
+    }
+
+    pub fn name(mut self, value: &str) -> roto_runtime::Result<Self> {
+        self.builder.write_string(1, value)?;
+        self.name_written = true;
+        Ok(self)
+    }
+
+    pub fn insertion_point(mut self, value: &str) -> roto_runtime::Result<Self> {
+        self.builder.write_string(2, value)?;
+        self.insertion_point_written = true;
+        Ok(self)
+    }
+
+    pub fn content(mut self, value: &str) -> roto_runtime::Result<Self> {
+        self.builder.write_string(15, value)?;
+        self.content_written = true;
+        Ok(self)
+    }
+
+    pub fn generated_code_info(mut self, value: &[u8]) -> roto_runtime::Result<Self> {
+        self.builder.write_bytes(16, value)?;
+        self.generated_code_info_written = true;
+        Ok(self)
+    }
+
+    pub fn with(mut self, msg: &File<'_>) -> roto_runtime::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)
+    }
+
+    pub fn finish(self) -> roto_runtime::Result<&'b mut [u8]> {
+        self.builder.finish()
+    }
+}
+
+}
+