feat: init

libraries/native_model/native_model_macro/src/method/decode_body.rs

@@ -0,0 +1,15 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub(crate) fn generate_native_model_decode_body() -> TokenStream {
+    let gen = quote! {
+        fn native_model_decode_body(data: Vec<u8>) -> Result<Self, native_model::DecodeBodyError> {
+            native_model_decode_body(data).map_err(|e| native_model::DecodeBodyError {
+                msg: format!("{}", e),
+                source: e.into(),
+            })
+        }
+    };
+
+    gen.into()
+}

libraries/native_model/native_model_macro/src/method/decode_upgrade_body.rs

@@ -0,0 +1,50 @@
+use crate::ModelAttributes;
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub(crate) fn generate_native_model_decode_upgrade_body(attrs: &ModelAttributes) -> TokenStream {
+    let native_model_from = attrs.from.clone();
+    let native_model_try_from = attrs.try_from.clone();
+
+    let model_from_or_try_from = if let Some(from) = native_model_from {
+        quote! {
+            #from::native_model_decode_upgrade_body(data, x).map(|a| a.into())
+        }
+    } else if let Some((try_from, error_try_from)) = native_model_try_from {
+        quote! {
+            let result = #try_from::native_model_decode_upgrade_body(data, x).map(|b| {
+                b.try_into()
+                    .map_err(|e: #error_try_from| native_model::UpgradeError {
+                        msg: format!("{}", e),
+                        source: e.into(),
+                    })
+            })??;
+            Ok(result)
+        }
+    } else {
+        quote! {
+            Err(native_model::Error::UpgradeNotSupported {
+                from: x,
+                to: Self::native_model_version(),
+            })
+        }
+    };
+
+    let gen = quote! {
+        fn native_model_decode_upgrade_body(data: Vec<u8>, x: u32) -> native_model::Result<Self> {
+            if x == Self::native_model_version() {
+                let result = Self::native_model_decode_body(data)?;
+                Ok(result)
+            } else if x < Self::native_model_version() {
+                #model_from_or_try_from
+            } else {
+                Err(native_model::Error::UpgradeNotSupported {
+                    from: x,
+                    to: Self::native_model_version(),
+                })
+            }
+        }
+    };
+
+    gen
+}

libraries/native_model/native_model_macro/src/method/encode_body.rs

@@ -0,0 +1,15 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub(crate) fn generate_native_model_encode_body() -> TokenStream {
+    let gen = quote! {
+        fn native_model_encode_body(&self) -> Result<Vec<u8>, native_model::EncodeBodyError> {
+            native_model_encode_body(self).map_err(|e| native_model::EncodeBodyError {
+                msg: format!("{}", e),
+                source: e.into(),
+            })
+        }
+    };
+
+    gen.into()
+}

libraries/native_model/native_model_macro/src/method/encode_downgrade_body.rs

@@ -0,0 +1,54 @@
+use crate::ModelAttributes;
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub(crate) fn generate_native_model_encode_downgrade_body(attrs: &ModelAttributes) -> TokenStream {
+    let native_model_from = attrs.from.clone();
+    let native_model_try_from = attrs.try_from.clone();
+
+    let model_from_or_try_from = if let Some(from) = native_model_from {
+        quote! {
+            #from::native_model_encode_downgrade_body(self.into(), version)
+        }
+    } else if let Some((try_from, error_try_from)) = native_model_try_from {
+        quote! {
+            let result = #try_from::native_model_encode_downgrade_body(
+                self.try_into()
+                    .map_err(|e: #error_try_from| native_model::DowngradeError {
+                        msg: format!("{}", e),
+                        source: e.into(),
+                    })?,
+                version,
+            )?;
+            Ok(result)
+        }
+    } else {
+        quote! {
+            Err(native_model::Error::DowngradeNotSupported {
+                from: version,
+                to: Self::native_model_version(),
+            })
+        }
+    };
+
+    let gen = quote! {
+        fn native_model_encode_downgrade_body(self, version: u32) -> native_model::Result<Vec<u8>> {
+            if version == Self::native_model_version() {
+                let result = self.native_model_encode_body()?;
+                Ok(result)
+            } else if version < Self::native_model_version() {
+                #model_from_or_try_from
+            } else {
+                Err(native_model::Error::DowngradeNotSupported {
+                    from: version,
+                    to: Self::native_model_version(),
+                })
+            }
+        }
+    };
+
+    gen
+}
+
+// #[error("Wrong type id expected: {}, actual: {}", expected, actual)]
+// WrongTypeId { expected: u32, actual: u32 },

libraries/native_model/native_model_macro/src/method/id.rs

@@ -0,0 +1,13 @@
+use crate::ModelAttributes;
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub(crate) fn generate_native_model_id(model_attributes: &ModelAttributes) -> TokenStream {
+    let native_model_id = model_attributes.id.clone().unwrap();
+    let gen = quote! {
+        fn native_model_id() -> u32 {
+            #native_model_id
+        }
+    };
+    gen
+}

libraries/native_model/native_model_macro/src/method/mod.rs

@@ -0,0 +1,13 @@
+mod decode_body;
+mod decode_upgrade_body;
+mod encode_body;
+mod encode_downgrade_body;
+mod id;
+mod version;
+
+pub(crate) use decode_body::*;
+pub(crate) use decode_upgrade_body::*;
+pub(crate) use encode_body::*;
+pub(crate) use encode_downgrade_body::*;
+pub(crate) use id::*;
+pub(crate) use version::*;

libraries/native_model/native_model_macro/src/method/version.rs

@@ -0,0 +1,13 @@
+use crate::ModelAttributes;
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub(crate) fn generate_native_model_version(model_attributes: &ModelAttributes) -> TokenStream {
+    let native_model_version = model_attributes.version.clone().unwrap();
+    let gen = quote! {
+        fn native_model_version() -> u32 {
+            #native_model_version
+        }
+    };
+    gen
+}