1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
use serde::de::{Deserializer, Visitor};
use serde::ser::Serializer;
use serde::{Deserialize, Serialize};
use std::fmt;
use wasmer_compiler::CompiledFunctionFrameInfo;
#[derive(Clone, Serialize, Deserialize)]
#[serde(transparent)]
#[repr(transparent)]
pub struct UnprocessedFunctionFrameInfo {
#[serde(with = "serde_bytes")]
bytes: Vec<u8>,
}
impl UnprocessedFunctionFrameInfo {
pub fn deserialize(&self) -> CompiledFunctionFrameInfo {
bincode::deserialize(&self.bytes).expect("Can't deserialize the info")
}
pub fn serialize(processed: &CompiledFunctionFrameInfo) -> Self {
let bytes = bincode::serialize(&processed).expect("Can't serialize the info");
Self { bytes }
}
}
#[derive(Clone)]
pub enum SerializableFunctionFrameInfo {
Unprocessed(UnprocessedFunctionFrameInfo),
Processed(CompiledFunctionFrameInfo),
}
impl SerializableFunctionFrameInfo {
pub fn is_unprocessed(&self) -> bool {
matches!(self, Self::Unprocessed(_))
}
}
impl Serialize for SerializableFunctionFrameInfo {
fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let unprocessed = match self {
Self::Processed(processed) => UnprocessedFunctionFrameInfo::serialize(processed),
Self::Unprocessed(unprocessed) => unprocessed.clone(),
};
s.serialize_bytes(&unprocessed.bytes)
}
}
struct FunctionFrameInfoVisitor;
impl<'de> Visitor<'de> for FunctionFrameInfoVisitor {
type Value = UnprocessedFunctionFrameInfo;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("bytes")
}
fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> {
Ok(UnprocessedFunctionFrameInfo { bytes: v })
}
fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> {
Ok(UnprocessedFunctionFrameInfo { bytes: v.to_vec() })
}
}
impl<'de> Deserialize<'de> for SerializableFunctionFrameInfo {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(Self::Unprocessed(
deserializer.deserialize_byte_buf(FunctionFrameInfoVisitor)?,
))
}
}