Snap for 11926388 from daf0da49e66ba1edd37602374120b34589ba0fda to 24Q3-release Change-Id: Ib13aed753b6b759306a58401f9b33a448015df97
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json index c80110d..d308c05 100644 --- a/.cargo_vcs_info.json +++ b/.cargo_vcs_info.json
@@ -1,6 +1,6 @@ { "git": { - "sha1": "1aca6665980cddba4f12c36b13080694f1d76b4d" + "sha1": "4dbe66da6a922c64436a8f3a00a4ab1f0ebafbb6" }, "path_in_vcs": "pdl-runtime" } \ No newline at end of file
diff --git a/Android.bp b/Android.bp index f1fe3ae..f7bb4b0 100644 --- a/Android.bp +++ b/Android.bp
@@ -8,7 +8,7 @@ host_supported: true, crate_name: "pdl_runtime", cargo_env_compat: true, - cargo_pkg_version: "0.2.3", + cargo_pkg_version: "0.3.0", crate_root: "src/lib.rs", edition: "2021", rustlibs: [
diff --git a/Cargo.toml b/Cargo.toml index da7d0f1..cd91184 100644 --- a/Cargo.toml +++ b/Cargo.toml
@@ -12,7 +12,7 @@ [package] edition = "2021" name = "pdl-runtime" -version = "0.2.3" +version = "0.3.0" authors = [ "Henri Chataing <henrichataing@google.com>", "David de Jesus Duarte <licorne@google.com>",
diff --git a/Cargo.toml.orig b/Cargo.toml.orig index 986c1c2..e1d300f 100644 --- a/Cargo.toml.orig +++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@ [package] name = "pdl-runtime" -version = "0.2.3" +version = "0.3.0" edition = "2021" description = "PDL's runtime library" repository = "https://github.com/google/pdl/"
diff --git a/METADATA b/METADATA index d2e51db..daa6821 100644 --- a/METADATA +++ b/METADATA
@@ -8,13 +8,13 @@ license_type: NOTICE last_upgrade_date { year: 2024 - month: 2 - day: 5 + month: 5 + day: 29 } identifier { type: "crates.io" - value: "https://static.crates.io/crates/pdl-runtime/pdl-runtime-0.2.3.crate" - version: "0.2.2" + value: "https://static.crates.io/crates/pdl-runtime/pdl-runtime-0.3.0.crate" + version: "0.3.0" } identifier { type: "Archive"
diff --git a/README.md b/README.md index 1396b3d..a8e96fc 100644 --- a/README.md +++ b/README.md
@@ -45,5 +45,5 @@ ## Similar projects - [Kaitai](https://kaitai.io) -- [EMBOSS](https://github.com/kimrutherford/EMBOSS) +- [Emboss](https://github.com/google/emboss) - [P4](https://p4.org/p4-spec/docs/P4-16-v1.0.0-spec.html)
diff --git a/src/lib.rs b/src/lib.rs index 4e78bf9..32d26dc 100644 --- a/src/lib.rs +++ b/src/lib.rs
@@ -14,32 +14,114 @@ //! Helper definitions used used by the generated Rust backend. -use bytes::Bytes; -use thiserror::Error; +use bytes::{BufMut, Bytes, BytesMut}; /// Type of parsing errors. -#[derive(Debug, Error, PartialEq, Eq)] -pub enum Error { - #[error("Packet parsing failed")] +#[derive(Debug, thiserror::Error, PartialEq, Eq)] +pub enum DecodeError { + #[error("packet parsing failed")] InvalidPacketError, #[error("{field} was {value:x}, which is not known")] - ConstraintOutOfBounds { field: String, value: u64 }, + ConstraintOutOfBounds { field: &'static str, value: u64 }, #[error("Got {actual:x}, expected {expected:x}")] InvalidFixedValue { expected: u64, actual: u64 }, #[error("when parsing {obj} needed length of {wanted} but got {got}")] - InvalidLengthError { obj: String, wanted: usize, got: usize }, + InvalidLengthError { obj: &'static str, wanted: usize, got: usize }, #[error("array size ({array} bytes) is not a multiple of the element size ({element} bytes)")] InvalidArraySize { array: usize, element: usize }, #[error("Due to size restrictions a struct could not be parsed.")] ImpossibleStructError, #[error("when parsing field {obj}.{field}, {value} is not a valid {type_} value")] - InvalidEnumValueError { obj: String, field: String, value: u64, type_: String }, + InvalidEnumValueError { + obj: &'static str, + field: &'static str, + value: u64, + type_: &'static str, + }, + #[error("invalid field {packet}::{field} value, {expected} != {actual}")] + InvalidFieldValue { + packet: &'static str, + field: &'static str, + expected: &'static str, + actual: String, + }, #[error("expected child {expected}, got {actual}")] InvalidChildError { expected: &'static str, actual: String }, + #[error("packet has trailing bytes")] + TrailingBytes, + #[error("packet has trailing bytes inside {obj}.{field} array")] + TrailingBytesInArray { obj: &'static str, field: &'static str }, +} + +/// Type of serialization errors. +#[derive(Debug, thiserror::Error, PartialEq, Eq)] +pub enum EncodeError { + #[error("the size of {packet}::{field} ({size}) is outside the range of valid values 0..{maximum_size}")] + SizeOverflow { packet: &'static str, field: &'static str, size: usize, maximum_size: usize }, + #[error( + "the count of {packet}::{field} ({count}) is outside the range of valid values 0..{maximum_count}" + )] + CountOverflow { packet: &'static str, field: &'static str, count: usize, maximum_count: usize }, + #[error( + "the value of {packet}::{field} ({value}) is outside the range of valid values 0..{maximum_value}" + )] + InvalidScalarValue { packet: &'static str, field: &'static str, value: u64, maximum_value: u64 }, + #[error( + "{packet}.{field}[{element_index}] size is {size}, but {expected_size} was expected (size of {packet}.{field}[0])" + )] + InvalidArrayElementSize { + packet: &'static str, + field: &'static str, + size: usize, + expected_size: usize, + element_index: usize, + }, } /// Trait implemented for all toplevel packet declarations. -pub trait Packet { - fn to_bytes(self) -> Bytes; - fn to_vec(self) -> Vec<u8>; +pub trait Packet: Sized { + /// Try parsing an instance of Self from the input slice. + /// On success, returns the parsed object and the remaining unparsed slice. + /// On failure, returns an error with the reason for the parsing failure. + fn decode(buf: &[u8]) -> Result<(Self, &[u8]), DecodeError>; + + /// Try parsing an instance of Packet updating the slice in place + /// to the remainder of the data. The input buffer is not updated if + /// parsing fails. + fn decode_mut(buf: &mut &[u8]) -> Result<Self, DecodeError> { + let (packet, remaining) = Self::decode(buf)?; + *buf = remaining; + Ok(packet) + } + + /// Try parsing an instance of Packet from the input slice. + /// Returns an error if unparsed bytes remain at the end of the input slice. + fn decode_full(buf: &[u8]) -> Result<Self, DecodeError> { + let (packet, remaining) = Self::decode(buf)?; + if remaining.is_empty() { + Ok(packet) + } else { + Err(DecodeError::TrailingBytes) + } + } + + /// Return the length of the encoded packet. + fn encoded_len(&self) -> usize; + + /// Write the packet to an output buffer. + fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>; + + /// Encode the packet to a byte vector. + fn encode_to_vec(&self) -> Result<Vec<u8>, EncodeError> { + let mut buf = Vec::with_capacity(self.encoded_len()); + self.encode(&mut buf)?; + Ok(buf) + } + + /// Encode the packet to a Bytes object. + fn encode_to_bytes(&self) -> Result<Bytes, EncodeError> { + let mut buf = BytesMut::with_capacity(self.encoded_len()); + self.encode(&mut buf)?; + Ok(buf.freeze()) + } }