add maps and flat modifier

Signed-off-by: Valentyn Faychuk <valy@faychuk.com>

Author: valentynfaychuk

contract_samples/rust/examples/counter_macros.rs

@@ -0,0 +1,100 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+use alloc::vec::Vec;
+use alloc::string::{String, ToString};
+use amadeus_sdk::*;
+
+#[contract_state]
+struct Match {
+    #[flat] score: u16,
+    #[flat] opponent: String,
+}
+
+#[contract_state]
+struct TournamentInfo {
+    #[flat] name: String,
+    #[flat] prize_pool: u64,
+}
+
+#[contract_state]
+struct Leaderboard {
+    #[flat] total_matches: i32,
+    player_wins: Map<String, u32>,
+    players: MapNested<String, MapNested<u64, Match>>,
+    tournament: TournamentInfo,
+}
+
+#[contract]
+impl Leaderboard {
+    pub fn increment_total_matches(&mut self) {
+        *self.total_matches += 1;
+    }
+
+    pub fn get_total_matches(&mut self) -> Vec<u8> {
+        (*self.total_matches).to_string().into_bytes()
+    }
+
+    pub fn record_match(&mut self, player: String, match_id: Vec<u8>, score: Vec<u8>, opponent: String) {
+        let match_id_u64 = u64::from_bytes(match_id);
+        self.players.with_mut(player, |matches| {
+            matches.with_mut(match_id_u64, |m| {
+                *m.score = u16::from_bytes(score);
+                *m.opponent = opponent;
+            });
+        });
+        *self.total_matches += 1;
+    }
+
+    pub fn get_match_score(&mut self, player: String, match_id: Vec<u8>) -> Vec<u8> {
+        let match_id_u64 = u64::from_bytes(match_id);
+        self.players.with_mut(player, |matches| {
+            matches.with_mut(match_id_u64, |m| {
+                (*m.score).to_string().into_bytes()
+            })
+        })
+    }
+
+    pub fn get_match_opponent(&mut self, player: String, match_id: Vec<u8>) -> String {
+        let match_id_u64 = u64::from_bytes(match_id);
+        self.players.with_mut(player, |matches| {
+            matches.with_mut(match_id_u64, |m| {
+                (*m.opponent).clone()
+            })
+        })
+    }
+
+    pub fn set_tournament_info(&mut self, name: String, prize_pool: Vec<u8>) {
+        *self.tournament.name = name;
+        *self.tournament.prize_pool = u64::from_bytes(prize_pool);
+    }
+
+    pub fn get_tournament_name(&mut self) -> String {
+        (*self.tournament.name).clone()
+    }
+
+    pub fn get_tournament_prize(&mut self) -> Vec<u8> {
+        (*self.tournament.prize_pool).to_string().into_bytes()
+    }
+
+    pub fn record_win(&mut self, player: String) {
+        if let Some(wins) = self.player_wins.get_mut(&player) {
+            **wins += 1;
+        } else {
+            self.player_wins.insert(player, 1);
+        }
+    }
+
+    pub fn get_player_wins(&mut self, player: String) -> Vec<u8> {
+        if let Some(wins) = self.player_wins.get(&player) {
+            (*wins).to_string().into_bytes()
+        } else {
+            "0".to_string().into_bytes()
+        }
+    }
+
+    pub fn set_player_wins(&mut self, player: String, wins: Vec<u8>) {
+        self.player_wins.insert(player, u32::from_bytes(wins));
+    }
+}

contract_samples/rust/examples/showcase.rs

@@ -13,27 +13,45 @@ pub fn contract_state(_attr: TokenStream, item: TokenStream) -> TokenStream {
         return TokenStream::from(quote! { #input });
     };
 
-    let is_nested = |f: &syn::Field| -> bool {
-        f.attrs.iter().any(|attr| attr.path().is_ident("nested"))
+    let is_flat = |f: &syn::Field| -> bool {
+        f.attrs.iter().any(|attr| attr.path().is_ident("flat"))
+    };
+
+    let is_map = |f: &syn::Field| -> bool {
+        if let Type::Path(type_path) = &f.ty {
+            if let Some(segment) = type_path.path.segments.first() {
+                return segment.ident == "Map";
+            }
+        }
+        false
+    };
+
+    let is_map_nested = |f: &syn::Field| -> bool {
+        if let Type::Path(type_path) = &f.ty {
+            if let Some(segment) = type_path.path.segments.first() {
+                return segment.ident == "MapNested";
+            }
+        }
+        false
     };
 
     let transformed_fields = fields.named.iter().map(|f| {
         let field_name = &f.ident;
         let field_vis = &f.vis;
         let field_ty = &f.ty;
         let filtered_attrs: Vec<_> = f.attrs.iter()
-            .filter(|attr| !attr.path().is_ident("nested"))
+            .filter(|attr| !attr.path().is_ident("flat"))
             .collect();
 
-        if is_nested(f) {
+        if is_flat(f) {
             quote! {
                 #(#filtered_attrs)*
-                #field_vis #field_name: #field_ty
+                #field_vis #field_name: LazyCell<#field_ty>
             }
         } else {
             quote! {
                 #(#filtered_attrs)*
-                #field_vis #field_name: LazyCell<#field_ty>
+                #field_vis #field_name: #field_ty
             }
         }
     });
@@ -42,29 +60,35 @@ pub fn contract_state(_attr: TokenStream, item: TokenStream) -> TokenStream {
         let field = f.ident.as_ref().unwrap();
         let key = field.to_string();
 
-        if is_nested(f) {
+        if is_flat(f) {
+            quote! {
+                let mut key = prefix.clone();
+                key.extend_from_slice(#key.as_bytes());
+                self.#field = LazyCell::new(key);
+            }
+        } else if is_map(f) || is_map_nested(f) {
             quote! {
                 let mut key = prefix.clone();
                 key.extend_from_slice(#key.as_bytes());
-                key.push(b':');
                 self.#field.__init_lazy_fields(key);
             }
         } else {
             quote! {
                 let mut key = prefix.clone();
                 key.extend_from_slice(#key.as_bytes());
-                self.#field = LazyCell::new(key);
+                key.push(b':');
+                self.#field.__init_lazy_fields(key);
             }
         }
     });
 
     let flush_calls = fields.named.iter().map(|f| {
         let field = f.ident.as_ref().unwrap();
 
-        if is_nested(f) {
-            quote! { self.#field.__flush_lazy_fields(); }
-        } else {
+        if is_flat(f) {
             quote! { self.#field.flush(); }
+        } else {
+            quote! { self.#field.__flush_lazy_fields(); }
         }
     });
 

contract_samples/rust/sdk-macros/src/lib.rs

@@ -34,5 +34,5 @@ name = "nft"
 path = "../examples/nft.rs"
 
 [[example]]
-name = "counter_macros"
-path = "../examples/counter_macros.rs"
+name = "showcase"
+path = "../examples/showcase.rs"