boltffi_bindgen 0.24.1

Code generation library for BoltFFI - generates Swift, Kotlin, and TypeScript bindings
Documentation 
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use serde::{Deserialize, Serialize};

use super::class::Constructor;
use super::layout::{CLayout, Size, StructLayout};
use super::method::Method;
use super::types::{Deprecation, Type};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Record {
    pub name: String,
    #[serde(default = "default_true")]
    pub is_repr_c: bool,
    #[serde(default)]
    pub is_error: bool,
    pub fields: Vec<RecordField>,
    #[serde(default)]
    pub constructors: Vec<Constructor>,
    #[serde(default)]
    pub methods: Vec<Method>,
    pub doc: Option<String>,
    pub deprecated: Option<Deprecation>,
}

fn default_true() -> bool {
    true
}

impl Record {
    pub fn new(name: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            is_repr_c: true,
            is_error: false,
            fields: Vec::new(),
            constructors: Vec::new(),
            methods: Vec::new(),
            doc: None,
            deprecated: None,
        }
    }

    pub fn with_repr_c(mut self, is_repr_c: bool) -> Self {
        self.is_repr_c = is_repr_c;
        self
    }

    pub fn as_error(mut self) -> Self {
        self.is_error = true;
        self
    }

    pub fn with_field(mut self, field: RecordField) -> Self {
        self.fields.push(field);
        self
    }

    pub fn with_constructor(mut self, constructor: Constructor) -> Self {
        self.constructors.push(constructor);
        self
    }

    pub fn with_method(mut self, method: Method) -> Self {
        self.methods.push(method);
        self
    }

    pub fn has_methods(&self) -> bool {
        !self.constructors.is_empty() || !self.methods.is_empty()
    }

    pub fn with_doc(mut self, doc: impl Into<String>) -> Self {
        self.doc = Some(doc.into());
        self
    }

    pub fn maybe_doc(self, doc: Option<String>) -> Self {
        match doc {
            Some(d) => self.with_doc(d),
            None => self,
        }
    }

    pub fn with_deprecated(mut self, deprecation: Deprecation) -> Self {
        self.deprecated = Some(deprecation);
        self
    }

    pub fn is_deprecated(&self) -> bool {
        self.deprecated.is_some()
    }

    pub fn field_count(&self) -> usize {
        self.fields.len()
    }

    pub fn is_blittable(&self) -> bool {
        self.fields
            .iter()
            .all(|field| field.field_type.is_primitive())
    }

    pub fn layout(&self) -> StructLayout {
        StructLayout::from_layouts(self.fields.iter().map(|field| field.field_type.c_layout()))
    }

    pub fn struct_size(&self) -> Size {
        self.layout().total_size()
    }

    pub fn field_offsets(&self) -> Vec<usize> {
        self.layout()
            .offsets()
            .map(|offset| offset.as_usize())
            .collect()
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecordField {
    pub name: String,
    pub field_type: Type,
    pub doc: Option<String>,
    pub default_value: Option<String>,
}

impl RecordField {
    pub fn new(name: impl Into<String>, field_type: Type) -> Self {
        Self {
            name: name.into(),
            field_type,
            doc: None,
            default_value: None,
        }
    }

    pub fn with_default(mut self, value: impl Into<String>) -> Self {
        self.default_value = Some(value.into());
        self
    }

    pub fn with_doc(mut self, doc: impl Into<String>) -> Self {
        self.doc = Some(doc.into());
        self
    }
}