First pass at plugin gen

2026-05-02 22:48:03 -07:00
parent 33449d00c8
commit 8ae8c5dfd3
8 changed files with 2765 additions and 203 deletions
@@ -533,6 +533,284 @@ impl<'b> GeneratedCodeInfoBuilder<'b> {
    }
 }

+pub struct Version<'a>(ProtoAccessor<'a>);
+
+impl<'a> Version<'a> {
+    pub fn new(data: &'a [u8]) -> Result<Self> {
+        Ok(Self(ProtoAccessor::new(data)?))
+    }
+
+    pub fn major(&self) -> Result<i32> {
+        let (bytes, _) = self.0.get_value(1)?;
+        let (val, _) = crate::read_varint(bytes)?;
+        Ok(val as i32)
+    }
+
+    pub fn minor(&self) -> Result<i32> {
+        let (bytes, _) = self.0.get_value(2)?;
+        let (val, _) = crate::read_varint(bytes)?;
+        Ok(val as i32)
+    }
+
+    pub fn patch(&self) -> Result<i32> {
+        let (bytes, _) = self.0.get_value(3)?;
+        let (val, _) = crate::read_varint(bytes)?;
+        Ok(val as i32)
+    }
+
+    pub fn suffix(&self) -> Result<&'a str> {
+        let (bytes, _) = self.0.get_value(4)?;
+        str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation)
+    }
+
+    pub fn builder(buf: &mut [u8]) -> VersionBuilder<'_> {
+        VersionBuilder {
+            builder: ProtoBuilder::new(buf),
+        }
+    }
+}
+
+pub struct VersionBuilder<'b> {
+    builder: ProtoBuilder<'b>,
+}
+
+impl<'b> VersionBuilder<'b> {
+    pub fn major(mut self, value: i32) -> Result<Self> {
+        self.builder.write_int32(1, value)?;
+        Ok(self)
+    }
+
+    pub fn minor(mut self, value: i32) -> Result<Self> {
+        self.builder.write_int32(2, value)?;
+        Ok(self)
+    }
+
+    pub fn patch(mut self, value: i32) -> Result<Self> {
+        self.builder.write_int32(3, value)?;
+        Ok(self)
+    }
+
+    pub fn suffix(mut self, value: &str) -> Result<Self> {
+        self.builder.write_string(4, value)?;
+        Ok(self)
+    }
+
+    pub fn finish(self) -> Result<&'b mut [u8]> {
+        self.builder.finish()
+    }
+}
+
+pub struct CodeGeneratorRequest<'a>(ProtoAccessor<'a>);
+
+impl<'a> CodeGeneratorRequest<'a> {
+    pub fn new(data: &'a [u8]) -> Result<Self> {
+        Ok(Self(ProtoAccessor::new(data)?))
+    }
+
+    pub fn file_to_generate(&self) -> crate::RepeatedFieldIterator<'a> {
+        self.0.iter_repeated(1)
+    }
+
+    pub fn parameter(&self) -> Result<&'a str> {
+        let (bytes, _) = self.0.get_value(2)?;
+        str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation)
+    }
+
+    pub fn compiler_version(&self) -> Result<&'a [u8]> {
+        let (bytes, _) = self.0.get_value(3)?;
+        Ok(bytes)
+    }
+
+    pub fn proto_file(&self) -> crate::RepeatedFieldIterator<'a> {
+        self.0.iter_repeated(15)
+    }
+
+    pub fn source_file_descriptors(&self) -> crate::RepeatedFieldIterator<'a> {
+        self.0.iter_repeated(17)
+    }
+
+    pub fn builder(buf: &mut [u8]) -> CodeGeneratorRequestBuilder<'_> {
+        CodeGeneratorRequestBuilder {
+            builder: ProtoBuilder::new(buf),
+        }
+    }
+}
+
+pub struct CodeGeneratorRequestBuilder<'b> {
+    builder: ProtoBuilder<'b>,
+}
+
+impl<'b> CodeGeneratorRequestBuilder<'b> {
+    pub fn add_file_to_generate(mut self, value: &str) -> Result<Self> {
+        self.builder.write_string(1, value)?;
+        Ok(self)
+    }
+
+    pub fn parameter(mut self, value: &str) -> Result<Self> {
+        self.builder.write_string(2, value)?;
+        Ok(self)
+    }
+
+    pub fn compiler_version(mut self, data: &[u8]) -> Result<Self> {
+        self.builder.write_bytes(3, data)?;
+        Ok(self)
+    }
+
+    pub fn add_proto_file(mut self, data: &[u8]) -> Result<Self> {
+        self.builder.write_bytes(15, data)?;
+        Ok(self)
+    }
+
+    pub fn add_source_file_descriptor(mut self, data: &[u8]) -> Result<Self> {
+        self.builder.write_bytes(17, data)?;
+        Ok(self)
+    }
+
+    pub fn finish(self) -> Result<&'b mut [u8]> {
+        self.builder.finish()
+    }
+}
+
+pub struct CodeGeneratorResponse<'a>(ProtoAccessor<'a>);
+
+impl<'a> CodeGeneratorResponse<'a> {
+    pub fn new(data: &'a [u8]) -> Result<Self> {
+        Ok(Self(ProtoAccessor::new(data)?))
+    }
+
+    pub fn error(&self) -> Result<&'a str> {
+        let (bytes, _) = self.0.get_value(1)?;
+        str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation)
+    }
+
+    pub fn supported_features(&self) -> Result<u64> {
+        let (bytes, _) = self.0.get_value(2)?;
+        let (val, _) = crate::read_varint(bytes)?;
+        Ok(val)
+    }
+
+    pub fn minimum_edition(&self) -> Result<i32> {
+        let (bytes, _) = self.0.get_value(3)?;
+        let (val, _) = crate::read_varint(bytes)?;
+        Ok(val as i32)
+    }
+
+    pub fn maximum_edition(&self) -> Result<i32> {
+        let (bytes, _) = self.0.get_value(4)?;
+        let (val, _) = crate::read_varint(bytes)?;
+        Ok(val as i32)
+    }
+
+    pub fn file(&self) -> crate::RepeatedFieldIterator<'a> {
+        self.0.iter_repeated(15)
+    }
+
+    pub fn builder(buf: &mut [u8]) -> CodeGeneratorResponseBuilder<'_> {
+        CodeGeneratorResponseBuilder {
+            builder: ProtoBuilder::new(buf),
+        }
+    }
+}
+
+pub struct CodeGeneratorResponseBuilder<'b> {
+    builder: ProtoBuilder<'b>,
+}
+
+impl<'b> CodeGeneratorResponseBuilder<'b> {
+    pub fn error(mut self, value: &str) -> Result<Self> {
+        self.builder.write_string(1, value)?;
+        Ok(self)
+    }
+
+    pub fn supported_features(mut self, value: u64) -> Result<Self> {
+        self.builder.write_varint(2, value)?;
+        Ok(self)
+    }
+
+    pub fn minimum_edition(mut self, value: i32) -> Result<Self> {
+        self.builder.write_int32(3, value)?;
+        Ok(self)
+    }
+
+    pub fn maximum_edition(mut self, value: i32) -> Result<Self> {
+        self.builder.write_int32(4, value)?;
+        Ok(self)
+    }
+
+    pub fn add_file(mut self, data: &[u8]) -> Result<Self> {
+        self.builder.write_bytes(15, data)?;
+        Ok(self)
+    }
+
+    pub fn finish(self) -> Result<&'b mut [u8]> {
+        self.builder.finish()
+    }
+}
+
+pub struct ResponseFile<'a>(ProtoAccessor<'a>);
+
+impl<'a> ResponseFile<'a> {
+    pub fn new(data: &'a [u8]) -> Result<Self> {
+        Ok(Self(ProtoAccessor::new(data)?))
+    }
+
+    pub fn name(&self) -> Result<&'a str> {
+        let (bytes, _) = self.0.get_value(1)?;
+        str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation)
+    }
+
+    pub fn insertion_point(&self) -> Result<&'a str> {
+        let (bytes, _) = self.0.get_value(2)?;
+        str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation)
+    }
+
+    pub fn content(&self) -> Result<&'a str> {
+        let (bytes, _) = self.0.get_value(15)?;
+        str::from_utf8(bytes).map_err(|_| RotoError::WireFormatViolation)
+    }
+
+    pub fn generated_code_info(&self) -> Result<&'a [u8]> {
+        let (bytes, _) = self.0.get_value(16)?;
+        Ok(bytes)
+    }
+
+    pub fn builder(buf: &mut [u8]) -> ResponseFileBuilder<'_> {
+        ResponseFileBuilder {
+            builder: ProtoBuilder::new(buf),
+        }
+    }
+}
+
+pub struct ResponseFileBuilder<'b> {
+    builder: ProtoBuilder<'b>,
+}
+
+impl<'b> ResponseFileBuilder<'b> {
+    pub fn name(mut self, value: &str) -> Result<Self> {
+        self.builder.write_string(1, value)?;
+        Ok(self)
+    }
+
+    pub fn insertion_point(mut self, value: &str) -> Result<Self> {
+        self.builder.write_string(2, value)?;
+        Ok(self)
+    }
+
+    pub fn content(mut self, value: &str) -> Result<Self> {
+        self.builder.write_string(15, value)?;
+        Ok(self)
+    }
+
+    pub fn generated_code_info(mut self, data: &[u8]) -> Result<Self> {
+        self.builder.write_bytes(16, data)?;
+        Ok(self)
+    }
+
+    pub fn finish(self) -> Result<&'b mut [u8]> {
+        self.builder.finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;