From fd5bbfd9644e38c570d98393459255cf5d3806de Mon Sep 17 00:00:00 2001 From: Vincent Herlemont Date: Sun, 29 Oct 2023 09:34:45 +0100 Subject: [PATCH] feat: add with macro option --- libraries/native_model/README.md | 32 +++++++----- libraries/native_model/README.md.skt.md | 52 ++++++++++++------- .../native_model_macro/src/lib.rs | 7 ++- .../src/method/decode_body.rs | 6 ++- .../src/method/encode_body.rs | 9 ++-- libraries/native_model/src/encode_decode.rs | 34 ++++++++++++ libraries/native_model/src/lib.rs | 2 + libraries/native_model/src/model.rs | 1 - .../tests/example/encode_decode/bincode.rs | 24 ++++----- .../example/encode_decode/bincode_serde.rs | 36 +++++++++---- .../tests/example/example_define_model.rs | 24 +++++---- .../tests/example/example_main.rs | 25 +++++---- libraries/native_model/tests/macro.rs | 22 +++++--- .../tests/macro_decode_decode_upgrade.rs | 24 ++++++--- .../native_model/tests/macro_encode_decode.rs | 20 ++++--- .../native_model/tests/native_model_from.rs | 21 +++++--- .../tests/native_model_try_from.rs | 21 +++++--- 17 files changed, 240 insertions(+), 120 deletions(-) create mode 100644 libraries/native_model/src/encode_decode.rs diff --git a/libraries/native_model/README.md b/libraries/native_model/README.md index e26268ff..2d569fc2 100644 --- a/libraries/native_model/README.md +++ b/libraries/native_model/README.md @@ -100,21 +100,28 @@ Under the hood, the native model is a thin wrapper around serialized data. The ` First, you need to set up your serialization format. You can use any serialization format. -Just define the following functions, so they must be imported in the scope where you use the native model. +Just define a struct with the name you want. This struct must implement [`native_model::Encode`](https://docs.rs/native_model/latest/native_model/trait.Encode.html) and [`native_model::Decode`](https://docs.rs/native_model/latest/native_model/trait.Decode.html) traits. -```rust,ignore -fn native_model_encode_body(obj: &T) -> Result, E> { - ... +In the below example we have created a struct `Bincode` that use the [bincode](https://docs.rs/bincode/latest/bincode/) crate: +```rust,skt-define-serilization-format +pub struct Bincode; + +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::encode_to_vec(obj, bincode::config::standard()) + } } -fn native_model_decode_body(data: Vec) -> Result { - ... +impl native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { + bincode::decode_from_slice(&data, bincode::config::standard()).map(|(result, _)| result) + } } ``` -With `T` and `E` the type depending on the serialization format you use. Just `E` need to implement the `std::error::Error` trait. - -Examples: +Full examples: - [bincode with encode/decode](./tests/example/encode_decode/bincode.rs) - [bincode with serde](./tests/example/encode_decode/bincode_serde.rs) @@ -126,6 +133,7 @@ Define your model using the macro [`native_model`](file:///home/vincentherlemont Attributes: - `id = u32`: The unique identifier of the model. - `version = u32`: The version of the model. +- `with = type`: The serialization format that you use for the Encode/Decode implementation. Setup [here](#setup-your-serialization-format). - `from = type`: Optional, the previous version of the model. - `type`: The previous version of the model that you use for the From implementation. - `try_from = (type, error)`: Optional, the previous version of the model with error handling. @@ -136,11 +144,11 @@ Attributes: use native_model::native_model; #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct DotV1(u32, u32); #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 2, from = DotV1)] +#[native_model(id = 1, version = 2, with = Bincode, from = DotV1)] struct DotV2 { name: String, x: u64, @@ -150,7 +158,7 @@ struct DotV2 { // Implement the conversion between versions From for DotV2 and From for DotV1. #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 3, try_from = (DotV2, anyhow::Error))] +#[native_model(id = 1, version = 3, with = Bincode, try_from = (DotV2, anyhow::Error))] struct DotV3 { name: String, cord: Cord, diff --git a/libraries/native_model/README.md.skt.md b/libraries/native_model/README.md.skt.md index 969e1ffb..9cb43ea9 100644 --- a/libraries/native_model/README.md.skt.md +++ b/libraries/native_model/README.md.skt.md @@ -1,30 +1,30 @@ ```rust,skt-main use bincode; -use bincode::{{Decode, Encode}}; +use bincode::{{Decode, Encode, config}}; use native_model_macro::native_model; -fn native_model_encode_body( - model: &T, -) -> Result, bincode::error::EncodeError> {{ - {{ - bincode::encode_to_vec(model, bincode::config::standard()) +pub struct Bincode; + +impl native_model::Encode for Bincode {{ + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> {{ + bincode::encode_to_vec(obj, config::standard()) }} }} -fn native_model_decode_body( - data: Vec, -) -> Result {{ - {{ - bincode::decode_from_slice(&data, bincode::config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode {{ + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result {{ + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) }} }} #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct DotV1(u32, u32); #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 2, from = DotV1)] +#[native_model(id = 1, version = 2, with = Bincode, from = DotV1)] struct DotV2 {{ name: String, x: u64, @@ -56,17 +56,22 @@ fn main() {{ ```rust,skt-define-models use bincode::{{config, Decode, Encode}}; -#[allow(dead_code)] -fn native_model_encode_body(obj: &T) -> Result, bincode::error::EncodeError> {{ - bincode::encode_to_vec(obj, config::standard()) +pub struct Bincode; + +impl native_model::Encode for Bincode {{ + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> {{ + bincode::encode_to_vec(obj, config::standard()) + }} }} -#[allow(dead_code)] -fn native_model_decode_body(data: Vec) -> Result {{ - bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode {{ + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result {{ + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) + }} }} - {} impl From for DotV2 {{ @@ -137,4 +142,11 @@ fn main() {{ ); }} +``` + +```rust,skt-define-serilization-format +{} + +fn main() {{ +}} ``` \ No newline at end of file diff --git a/libraries/native_model/native_model_macro/src/lib.rs b/libraries/native_model/native_model_macro/src/lib.rs index a048b68a..2dc20be2 100644 --- a/libraries/native_model/native_model_macro/src/lib.rs +++ b/libraries/native_model/native_model_macro/src/lib.rs @@ -21,6 +21,8 @@ pub(crate) struct ModelAttributes { pub(crate) id: Option, pub(crate) version: Option, // type + pub(crate) with: Option, + // type pub(crate) from: Option, // (type, try_from::Error type) pub(crate) try_from: Option<(Path, Path)>, @@ -32,6 +34,8 @@ impl ModelAttributes { self.id = Some(meta.value()?.parse()?); } else if meta.path.is_ident("version") { self.version = Some(meta.value()?.parse()?); + } else if meta.path.is_ident("with") { + self.with = Some(meta.value()?.parse()?); } else if meta.path.is_ident("from") { self.from = Some(meta.value()?.parse()?); } else if meta.path.is_ident("try_from") { @@ -72,6 +76,7 @@ impl Parse for TupleTryFrom { /// Attributes: /// - `id = u32`: The unique identifier of the model. /// - `version = u32`: The version of the model. +/// - `with` = type: Required, the serialization/deserialization library that you use. Must implement `native_model::Encode` and `native_model::Decode`. /// - `from = type`: Optional, the previous version of the model. /// - `type`: The previous version of the model that you use for the From implementation. /// - `try_from = (type, error)`: Optional, the previous version of the model with error handling. @@ -92,7 +97,7 @@ pub fn native_model(args: TokenStream, input: TokenStream) -> TokenStream { let native_model_id_fn = generate_native_model_id(&attrs); let native_model_version_fn = generate_native_model_version(&attrs); - let native_model_encode_body_fn = generate_native_model_encode_body(); + let native_model_encode_body_fn = generate_native_model_encode_body(&attrs); let native_model_encode_downgrade_body_fn = generate_native_model_encode_downgrade_body(&attrs); let native_model_decode_body_fn = generate_native_model_decode_body(&attrs); let native_model_decode_upgrade_body_fn = generate_native_model_decode_upgrade_body(&attrs); diff --git a/libraries/native_model/native_model_macro/src/method/decode_body.rs b/libraries/native_model/native_model_macro/src/method/decode_body.rs index 97ad509b..3ff228da 100644 --- a/libraries/native_model/native_model_macro/src/method/decode_body.rs +++ b/libraries/native_model/native_model_macro/src/method/decode_body.rs @@ -3,7 +3,8 @@ use proc_macro2::TokenStream; use quote::quote; pub(crate) fn generate_native_model_decode_body(attrs: &ModelAttributes) -> TokenStream { - let id = attrs.id.clone().expect("id is required"); + let id = attrs.id.clone().expect("`id` is required"); + let with = attrs.with.clone().expect("`with` is required"); let gen = quote! { fn native_model_decode_body(data: Vec, id: u32) -> Result { println!("id: {}, {}", id, #id); @@ -11,7 +12,8 @@ pub(crate) fn generate_native_model_decode_body(attrs: &ModelAttributes) -> Toke return Err(native_model::DecodeBodyError::MismatchedModelId); } - native_model_decode_body(data).map_err(|e| native_model::DecodeBodyError::DecodeError { + use native_model::Decode; + #with::decode(data).map_err(|e| native_model::DecodeBodyError::DecodeError { msg: format!("{}", e), source: e.into(), }) diff --git a/libraries/native_model/native_model_macro/src/method/encode_body.rs b/libraries/native_model/native_model_macro/src/method/encode_body.rs index 2fa097fe..f756063e 100644 --- a/libraries/native_model/native_model_macro/src/method/encode_body.rs +++ b/libraries/native_model/native_model_macro/src/method/encode_body.rs @@ -1,10 +1,13 @@ +use crate::ModelAttributes; use proc_macro2::TokenStream; use quote::quote; -pub(crate) fn generate_native_model_encode_body() -> TokenStream { +pub(crate) fn generate_native_model_encode_body(attrs: &ModelAttributes) -> TokenStream { + let with = attrs.with.clone().expect("`with` is required"); let gen = quote! { fn native_model_encode_body(&self) -> Result, native_model::EncodeBodyError> { - native_model_encode_body(self).map_err(|e| native_model::EncodeBodyError { + use native_model::Encode; + #with::encode(self).map_err(|e| native_model::EncodeBodyError { msg: format!("{}", e), source: e.into(), }) @@ -12,4 +15,4 @@ pub(crate) fn generate_native_model_encode_body() -> TokenStream { }; gen.into() -} \ No newline at end of file +} diff --git a/libraries/native_model/src/encode_decode.rs b/libraries/native_model/src/encode_decode.rs new file mode 100644 index 00000000..da436f71 --- /dev/null +++ b/libraries/native_model/src/encode_decode.rs @@ -0,0 +1,34 @@ +/// Encode trait for your own encoding method. +/// +/// Example: +/// ```rust +/// pub struct Bincode; +/// +/// impl native_model::Encode for Bincode { +/// type Error = bincode::error::EncodeError; +/// fn encode(obj: &T) -> Result, bincode::error::EncodeError> { +/// bincode::encode_to_vec(obj, bincode::config::standard()) +/// } +/// } +/// ``` +pub trait Encode { + type Error; + fn encode(obj: &T) -> Result, Self::Error>; +} + +/// Decode trait for your own decoding method. +/// +/// Example: +/// ```rust +/// pub struct Bincode; +/// +/// impl native_model::Decode for Bincode { +/// type Error = bincode::error::DecodeError; +/// fn decode(data: Vec) -> Result { +/// bincode::decode_from_slice(&data, bincode::config::standard()).map(|(result, _)| result) +/// } +/// } +pub trait Decode { + type Error; + fn decode(data: Vec) -> Result; +} diff --git a/libraries/native_model/src/lib.rs b/libraries/native_model/src/lib.rs index 7fbbf7ce..6cfc382e 100644 --- a/libraries/native_model/src/lib.rs +++ b/libraries/native_model/src/lib.rs @@ -15,10 +15,12 @@ //! //! See examples in the [README.md](https://github.com/vincent-herlemont/native_model) file. +mod encode_decode; mod header; mod model; pub mod wrapper; +pub use encode_decode::*; pub use model::*; /// Macro to generate a [`native_model`] implementation for a struct. diff --git a/libraries/native_model/src/model.rs b/libraries/native_model/src/model.rs index 08a9351e..b8307492 100644 --- a/libraries/native_model/src/model.rs +++ b/libraries/native_model/src/model.rs @@ -5,7 +5,6 @@ pub trait Model: Sized { fn native_model_version() -> u32; // --------------- Decode --------------- - fn native_model_decode_body(data: Vec, id: u32) -> DecodeResult where Self: Sized; diff --git a/libraries/native_model/tests/example/encode_decode/bincode.rs b/libraries/native_model/tests/example/encode_decode/bincode.rs index d3b8ce3f..71507775 100644 --- a/libraries/native_model/tests/example/encode_decode/bincode.rs +++ b/libraries/native_model/tests/example/encode_decode/bincode.rs @@ -1,26 +1,26 @@ use bincode; -use bincode::{Decode, Encode}; +use bincode::{config, Decode, Encode}; -fn native_model_encode_body( - model: &T, -) -> Result, bincode::error::EncodeError> { - { - bincode::encode_to_vec(model, bincode::config::standard()) +pub struct Bincode; + +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::encode_to_vec(obj, config::standard()) } } -fn native_model_decode_body( - data: Vec, -) -> Result { - { - bincode::decode_from_slice(&data, bincode::config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) } } use native_model_macro::native_model; #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct DotV1(u32, u32); #[test] diff --git a/libraries/native_model/tests/example/encode_decode/bincode_serde.rs b/libraries/native_model/tests/example/encode_decode/bincode_serde.rs index a4acd978..090bebd9 100644 --- a/libraries/native_model/tests/example/encode_decode/bincode_serde.rs +++ b/libraries/native_model/tests/example/encode_decode/bincode_serde.rs @@ -1,18 +1,34 @@ use bincode; use serde::{Deserialize, Serialize}; -fn native_model_encode_body( - model: &T, -) -> Result, bincode::error::EncodeError> { - { - bincode::serde::encode_to_vec(model, bincode::config::standard()) +// fn native_model_encode_body( +// model: &T, +// ) -> Result, bincode::error::EncodeError> { +// { +// bincode::serde::encode_to_vec(model, bincode::config::standard()) +// } +// } +// +// fn native_model_decode_body Deserialize<'a>>( +// data: Vec, +// ) -> Result { +// { +// Ok(bincode::serde::decode_from_slice(&data, bincode::config::standard())?.0) +// } +// } + +pub struct Bincode; + +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::serde::encode_to_vec(obj, bincode::config::standard()) } } -fn native_model_decode_body Deserialize<'a>>( - data: Vec, -) -> Result { - { +impl Deserialize<'a>> native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { Ok(bincode::serde::decode_from_slice(&data, bincode::config::standard())?.0) } } @@ -20,7 +36,7 @@ fn native_model_decode_body Deserialize<'a>>( use native_model_macro::native_model; #[derive(Serialize, Deserialize, PartialEq, Debug)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct DotV1(u32, u32); #[test] diff --git a/libraries/native_model/tests/example/example_define_model.rs b/libraries/native_model/tests/example/example_define_model.rs index 6deae702..14b204b3 100644 --- a/libraries/native_model/tests/example/example_define_model.rs +++ b/libraries/native_model/tests/example/example_define_model.rs @@ -1,22 +1,28 @@ use bincode::{config, Decode, Encode}; use native_model_macro::native_model; -#[allow(dead_code)] -fn native_model_encode_body(obj: &T) -> Result, bincode::error::EncodeError> { - bincode::encode_to_vec(obj, config::standard()) +pub struct Bincode; + +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::encode_to_vec(obj, config::standard()) + } } -#[allow(dead_code)] -fn native_model_decode_body(data: Vec) -> Result { - bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) + } } #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct DotV1(u32, u32); #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 2, from = DotV1)] +#[native_model(id = 1, version = 2, with = Bincode, from = DotV1)] struct DotV2 { name: String, x: u64, @@ -40,7 +46,7 @@ impl From for DotV1 { } #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 3, try_from = (DotV2, anyhow::Error))] +#[native_model(id = 1, version = 3, with = Bincode, try_from = (DotV2, anyhow::Error))] struct DotV3 { name: String, cord: Cord, diff --git a/libraries/native_model/tests/example/example_main.rs b/libraries/native_model/tests/example/example_main.rs index 5835c46b..d5374da2 100644 --- a/libraries/native_model/tests/example/example_main.rs +++ b/libraries/native_model/tests/example/example_main.rs @@ -1,29 +1,28 @@ use bincode; -use bincode::{Decode, Encode}; +use bincode::{config, Decode, Encode}; use native_model::native_model; -fn native_model_encode_body( - model: &T, -) -> Result, bincode::error::EncodeError> { - { - bincode::encode_to_vec(model, bincode::config::standard()) +pub struct Bincode; +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::encode_to_vec(obj, config::standard()) } } -fn native_model_decode_body( - data: Vec, -) -> Result { - { - bincode::decode_from_slice(&data, bincode::config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) } } #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct DotV1(u32, u32); #[derive(Encode, Decode, PartialEq, Debug)] -#[native_model(id = 1, version = 2, from = DotV1)] +#[native_model(id = 1, version = 2, with = Bincode, from = DotV1)] struct DotV2 { name: String, x: u64, diff --git a/libraries/native_model/tests/macro.rs b/libraries/native_model/tests/macro.rs index 1b1f48b0..4b687701 100644 --- a/libraries/native_model/tests/macro.rs +++ b/libraries/native_model/tests/macro.rs @@ -2,24 +2,30 @@ use bincode::{config, Decode, Encode}; use native_model::Model; use native_model_macro::native_model; -#[allow(dead_code)] -fn native_model_encode_body(obj: &T) -> Result, bincode::error::EncodeError> { - bincode::encode_to_vec(obj, config::standard()) +pub struct Bincode; + +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::encode_to_vec(obj, config::standard()) + } } -#[allow(dead_code)] -fn native_model_decode_body(data: Vec) -> Result { - bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) + } } #[derive(Debug, Encode, Decode)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct Foo1 { x: i32, } #[derive(Debug, Encode, Decode)] -#[native_model(id = 1, version = 2, from = Foo1)] +#[native_model(id = 1, version = 2, with = Bincode, from = Foo1)] struct Foo2 { x: i32, } diff --git a/libraries/native_model/tests/macro_decode_decode_upgrade.rs b/libraries/native_model/tests/macro_decode_decode_upgrade.rs index d007c1c4..a6e6aa71 100644 --- a/libraries/native_model/tests/macro_decode_decode_upgrade.rs +++ b/libraries/native_model/tests/macro_decode_decode_upgrade.rs @@ -2,22 +2,30 @@ use bincode::{config, Decode, Encode}; use native_model::Model; use native_model_macro::native_model; -fn native_model_encode_body(obj: &T) -> Result, bincode::error::EncodeError> { - bincode::encode_to_vec(obj, config::standard()) +pub struct Bincode; + +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::encode_to_vec(obj, config::standard()) + } } -fn native_model_decode_body(data: Vec) -> Result { - bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) + } } #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct Foo1 { x: i32, } #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 1, version = 2, from = Foo1)] +#[native_model(id = 1, version = 2, with = Bincode, from = Foo1)] struct Foo2 { x: String, } @@ -39,7 +47,7 @@ impl From for Foo1 { } #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 1, version = 3, from = Foo2)] +#[native_model(id = 1, version = 3, with = Bincode, from = Foo2)] enum Foo3 { X(i32), } @@ -149,7 +157,7 @@ fn test_should_fail_decode_foo2_to_foo1() { } #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 2, version = 1)] +#[native_model(id = 2, version = 1, with = Bincode)] struct Foo1Bis { x: i32, } diff --git a/libraries/native_model/tests/macro_encode_decode.rs b/libraries/native_model/tests/macro_encode_decode.rs index 37415c07..a2c42bab 100644 --- a/libraries/native_model/tests/macro_encode_decode.rs +++ b/libraries/native_model/tests/macro_encode_decode.rs @@ -2,22 +2,30 @@ use bincode::{config, Decode, Encode}; use native_model::Model; use native_model_macro::native_model; -fn native_model_encode_body(obj: &T) -> Result, bincode::error::EncodeError> { - bincode::encode_to_vec(obj, config::standard()) +pub struct Bincode; + +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::encode_to_vec(obj, config::standard()) + } } -fn native_model_decode_body(data: Vec) -> Result { - bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) + } } #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct Foo1 { x: i32, } #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 1, version = 2, from = Foo1)] +#[native_model(id = 1, version = 2, with = Bincode, from = Foo1)] struct Foo2 { x: i32, } diff --git a/libraries/native_model/tests/native_model_from.rs b/libraries/native_model/tests/native_model_from.rs index 6e0acf1f..4dd66ce4 100644 --- a/libraries/native_model/tests/native_model_from.rs +++ b/libraries/native_model/tests/native_model_from.rs @@ -1,22 +1,27 @@ use bincode::{config, Decode, Encode}; use native_model_macro::native_model; - -fn native_model_encode_body(obj: &T) -> Result, bincode::error::EncodeError> { - bincode::encode_to_vec(obj, config::standard()) +pub struct Bincode; +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::encode_to_vec(obj, config::standard()) + } } -fn native_model_decode_body(data: Vec) -> Result { - bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) + } } - #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct Foo1 { x: i32, } #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 1, version = 2, from = Foo1)] +#[native_model(id = 1, version = 2, with = Bincode, from = Foo1)] struct Foo2 { x: i32, c: char, diff --git a/libraries/native_model/tests/native_model_try_from.rs b/libraries/native_model/tests/native_model_try_from.rs index 8cea2743..c223d945 100644 --- a/libraries/native_model/tests/native_model_try_from.rs +++ b/libraries/native_model/tests/native_model_try_from.rs @@ -1,22 +1,29 @@ use bincode::{config, Decode, Encode}; use native_model_macro::native_model; -fn native_model_encode_body(obj: &T) -> Result, bincode::error::EncodeError> { - bincode::encode_to_vec(obj, config::standard()) +pub struct Bincode; + +impl native_model::Encode for Bincode { + type Error = bincode::error::EncodeError; + fn encode(obj: &T) -> Result, bincode::error::EncodeError> { + bincode::encode_to_vec(obj, config::standard()) + } } -fn native_model_decode_body(data: Vec) -> Result { - bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) +impl native_model::Decode for Bincode { + type Error = bincode::error::DecodeError; + fn decode(data: Vec) -> Result { + bincode::decode_from_slice(&data, config::standard()).map(|(result, _)| result) + } } - #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 1, version = 1)] +#[native_model(id = 1, version = 1, with = Bincode)] struct Foo1 { x: i32, } #[derive(Debug, Encode, Decode, PartialEq)] -#[native_model(id = 1, version = 2, try_from = (Foo1, anyhow::Error))] +#[native_model(id = 1, version = 2, with = Bincode, try_from = (Foo1, anyhow::Error))] struct Foo2 { x: i32, }