89 lines
2.4 KiB
Rust
89 lines
2.4 KiB
Rust
use serde::{Deserialize, Deserializer, Serialize, Serializer};
|
|
use serde::de::Error;
|
|
use sp_client::bitcoin::hex::{DisplayHex, FromHex};
|
|
use sp_client::bitcoin::OutPoint;
|
|
use std::collections::{BTreeMap, HashMap};
|
|
use crate::{pcd::Member, process::Process};
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct OutPointMemberMap(#[serde(with = "members_map")] pub HashMap<OutPoint, Member>);
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct OutPointProcessMap(#[serde(with = "outpoint_map")] pub HashMap<OutPoint, Process>);
|
|
|
|
pub mod members_map {
|
|
use super::*;
|
|
use crate::pcd::Member;
|
|
|
|
pub fn serialize<S>(
|
|
map: &HashMap<OutPoint, Member>,
|
|
serializer: S,
|
|
) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
let map: HashMap<OutPoint, Member> = map
|
|
.iter()
|
|
.map(|(k, v)| (*k, v.to_owned()))
|
|
.collect();
|
|
map.serialize(serializer)
|
|
}
|
|
|
|
pub fn deserialize<'de, D>(
|
|
deserializer: D,
|
|
) -> Result<HashMap<OutPoint, Member>, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
let map: HashMap<OutPoint, Member> = HashMap::deserialize(deserializer)?;
|
|
|
|
Ok(map)
|
|
}
|
|
}
|
|
|
|
pub mod outpoint_map {
|
|
use super::*;
|
|
use crate::process::Process;
|
|
|
|
pub fn serialize<S>(
|
|
map: &HashMap<OutPoint, Process>,
|
|
serializer: S,
|
|
) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
// Convert OutPoint keys to Strings
|
|
let map: HashMap<String, Process> = map
|
|
.into_iter()
|
|
.map(|(k, v)| (k.to_string(), v.clone()))
|
|
.collect();
|
|
|
|
// Serialize as HashMap<String, Process>
|
|
map.serialize(serializer)
|
|
}
|
|
|
|
pub fn deserialize<'de, D>(
|
|
deserializer: D,
|
|
) -> Result<HashMap<OutPoint, Process>, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
// Deserialize as HashMap<String, Process>
|
|
let map: HashMap<String, Process> = HashMap::deserialize(deserializer)?;
|
|
|
|
// Convert String keys back to OutPoint
|
|
let result: Result<HashMap<OutPoint, Process>, D::Error> = map
|
|
.into_iter()
|
|
.map(|(k, v)| {
|
|
let outpoint = k
|
|
.parse()
|
|
.map_err(serde::de::Error::custom)?;
|
|
Ok((outpoint, v))
|
|
})
|
|
.collect();
|
|
|
|
result
|
|
}
|
|
}
|
|
|