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
use marine::MarineModuleInterface;
use marine::MarineFunctionSignature;
use marine::IRecordType;
use marine::MRecordTypes;
use marine::itype_text_view;
use serde::Serialize;
use std::rc::Rc;
#[derive(Serialize)]
pub struct FunctionSignature {
pub name: String,
pub arguments: Vec<(String, String)>,
pub output_types: Vec<String>,
}
#[derive(Serialize)]
pub struct RecordType {
pub name: String,
pub id: u64,
pub fields: Vec<(String, String)>,
}
#[derive(Serialize)]
pub struct ServiceInterface {
pub function_signatures: Vec<FunctionSignature>,
pub record_types: Vec<RecordType>,
}
pub(crate) fn into_service_interface(
marine_interface: MarineModuleInterface<'_>,
) -> ServiceInterface {
let record_types = marine_interface.record_types;
let function_signatures = marine_interface
.function_signatures
.into_iter()
.map(|sign| serialize_function_signature(sign, record_types))
.collect();
let record_types = record_types
.iter()
.map(|(id, record)| serialize_record_type(*id, record.clone(), record_types))
.collect::<Vec<_>>();
ServiceInterface {
function_signatures,
record_types,
}
}
fn serialize_function_signature(
signature: MarineFunctionSignature,
record_types: &MRecordTypes,
) -> FunctionSignature {
let arguments = signature
.arguments
.iter()
.map(|arg| (arg.name.clone(), itype_text_view(&arg.ty, record_types)))
.collect();
let output_types = signature
.outputs
.iter()
.map(|itype| itype_text_view(itype, record_types))
.collect();
FunctionSignature {
name: signature.name.to_string(),
arguments,
output_types,
}
}
fn serialize_record_type(
id: u64,
record: Rc<IRecordType>,
record_types: &MRecordTypes,
) -> RecordType {
let fields = record
.fields
.iter()
.map(|field| (field.name.clone(), itype_text_view(&field.ty, record_types)))
.collect::<Vec<_>>();
RecordType {
name: record.name.clone(),
id,
fields,
}
}