95 lines
2.4 KiB
Markdown
95 lines
2.4 KiB
Markdown
- method (what's left to do except code?)
|
|
- generate .dex
|
|
- code
|
|
- edditable code format
|
|
- json serialize with serde
|
|
- sanity checks
|
|
- tests
|
|
- 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`
|