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
105
106
107
108
109
110
111
112
113
use fluence::fce;
use fluence_it_types::IValue;
use serde::Deserialize;
use serde::Serialize;
pub const AQUA_INTERPRETER_SUCCESS: i32 = 0;
#[fce]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct InterpreterOutcome {
pub ret_code: i32,
pub error_message: String,
pub data: Vec<u8>,
pub next_peer_pks: Vec<String>,
}
impl InterpreterOutcome {
pub fn from_ivalues(mut ivalues: Vec<IValue>) -> Result<Self, String> {
const OUTCOME_FIELDS_COUNT: usize = 4;
let record_values = match ivalues.remove(0) {
IValue::Record(record_values) => record_values,
v => {
return Err(format!(
"expected record for InterpreterOutcome, got {:?}",
v
))
}
};
let mut record_values = record_values.into_vec();
if record_values.len() != OUTCOME_FIELDS_COUNT {
return Err(format!(
"expected InterpreterOutcome struct with {} fields, got {:?}",
OUTCOME_FIELDS_COUNT, record_values
));
}
let ret_code = match record_values.remove(0) {
IValue::S32(ret_code) => ret_code,
v => return Err(format!("expected i32 for ret_code, got {:?}", v)),
};
let error_message = match record_values.remove(0) {
IValue::String(str) => str,
v => return Err(format!("expected string for data, got {:?}", v)),
};
let data = match record_values.remove(0) {
IValue::Array(array) => {
let array: Result<Vec<_>, _> = array
.into_iter()
.map(|v| match v {
IValue::U8(byte) => Ok(byte),
v => Err(format!("expected a byte, got {:?}", v)),
})
.collect();
array?
}
v => return Err(format!("expected Vec<u8> for data, got {:?}", v)),
};
let next_peer_pks = match record_values.remove(0) {
IValue::Array(ar_values) => {
let array = ar_values
.into_iter()
.map(|v| match v {
IValue::String(str) => Ok(str),
v => Err(format!("expected string for next_peer_pks, got {:?}", v)),
})
.collect::<Result<Vec<String>, _>>()?;
Ok(array)
}
v => Err(format!("expected array for next_peer_pks, got {:?}", v)),
}?;
let outcome = Self {
ret_code,
error_message,
data,
next_peer_pks,
};
Ok(outcome)
}
}