add annotations to generated dex

TODO.md

@@ -2,7 +2,94 @@
 - generate .dex
 - code
 - edditable code format
+- json serialize with serde
 - sanity checks
 - tests
-- DexValues will become a problem ? (eg need to clone the vector for the array)
+- PyRef
 - https://source.android.com/docs/core/runtime/dex-format#system-annotation
+
+
+
+```
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::hash::Hash;
+
+pub mod vectorize {
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+    use std::iter::FromIterator;
+    pub fn serialize<'a, T, K, V, S>(target: T, ser: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+        T: IntoIterator<Item = (&'a K, &'a V)>,
+        K: Serialize + 'a,
+        V: Serialize + 'a,
+    {
+        let container: Vec<_> = target.into_iter().collect();
+        serde::Serialize::serialize(&container, ser)
+    }
+
+    pub fn deserialize<'de, T, K, V, D>(des: D) -> Result<T, D::Error>
+    where
+        D: Deserializer<'de>,
+        T: FromIterator<(K, V)>,
+        K: Deserialize<'de>,
+        V: Deserialize<'de>,
+    {
+        let container: Vec<_> = serde::Deserialize::deserialize(des)?;
+        Ok(T::from_iter(container.into_iter()))
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, Hash)]
+struct KeyItem {
+    name: String,
+    len: u32,
+}
+
+impl KeyItem {
+    fn new(s: &str) -> Self {
+        Self {
+            name: s.into(),
+            len: s.len() as u32,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, Hash)]
+enum ValueItem {
+    String1(String),
+    String2(String),
+    Int(u32),
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+struct ToSerialize {
+    #[serde(with = "vectorize")]
+    map1: HashMap<KeyItem, ValueItem>,
+    #[serde(with = "vectorize")]
+    map2: HashMap<KeyItem, ValueItem>,
+}
+
+fn main() {
+    let value = ToSerialize {
+        map1: HashMap::from([
+            (KeyItem::new("plop"), ValueItem::String1("Plop".into())),
+            (KeyItem::new("plip"), ValueItem::String2("Plip".into())),
+            (KeyItem::new("lop"), ValueItem::Int(109)),
+        ]),
+        map2: HashMap::from([(
+            KeyItem::new("run"),
+            ValueItem::String1("Demons run when a good man goes to war".into()),
+        )]),
+    };
+    let serialized = serde_json::to_string(&value).unwrap();
+    println!("{serialized}");
+    assert_eq!(
+        serde_json::from_str::<ToSerialize>(&serialized).unwrap(),
+        value
+    );
+}
+```
+
+`cargo add serde -F derive && cargo add serde_json`