OLD | NEW |
| (Empty) |
1 {% macro encode(value, kind, level=0) %} | |
2 {% if kind|is_nullable %} | |
3 if {{value}} == nil { | |
4 {% if kind|is_interface %} | |
5 encoder.WriteInvalidInterface() | |
6 {% elif kind|is_handle %} | |
7 encoder.WriteInvalidHandle() | |
8 {% elif kind|is_union %} | |
9 encoder.WriteNullUnion() | |
10 {% else %} | |
11 encoder.WriteNullPointer() | |
12 {% endif %} | |
13 } else { | |
14 {% if not kind|is_union %} | |
15 {% set value = '(*'~value~')' %} | |
16 {% endif %} | |
17 {{encodeNonNullable(value, kind, level)|tab_indent()}} | |
18 } | |
19 {% else -%} | |
20 {{encodeNonNullable(value, kind, level)}} | |
21 {%- endif %} | |
22 {% endmacro %} | |
23 | |
24 | |
25 | |
26 {% macro encodeNonNullable(value, kind, level=0) %} | |
27 {% if kind|is_pointer %} | |
28 if err := encoder.WritePointer(); err != nil { | |
29 return err | |
30 } | |
31 {% elif kind|is_union and not kind|is_nullable %} | |
32 if {{value}} == nil { | |
33 return &bindings.ValidationError{bindings.UnexpectedNullUnion, "unexpect
ed null union"} | |
34 } | |
35 {% endif %} | |
36 {% if kind|is_struct or kind|is_union %} | |
37 if err := {{value}}.Encode(encoder); err != nil { | |
38 return err | |
39 } | |
40 {% elif kind|is_array %} | |
41 encoder.StartArray(uint32(len({{value}})), {{kind.kind|bit_size}}) | |
42 for _, elem{{level}} := range {{value}} { | |
43 {{encode('elem'~level, kind.kind, level+1)|tab_indent()}} | |
44 } | |
45 if err := encoder.Finish(); err != nil { | |
46 return err | |
47 } | |
48 {% elif kind|is_map %} | |
49 encoder.StartMap() | |
50 { | |
51 var keys{{level}} {{kind.key_kind|array|go_type}} | |
52 var values{{level}} {{kind.value_kind|array|go_type}} | |
53 if encoder.Deterministic() { | |
54 for key{{level}}, _ := range {{value}} { | |
55 keys{{level}} = append(keys{{level}}, key{{level}}) | |
56 } | |
57 bindings.SortMapKeys(&keys{{level}}) | |
58 values{{level}} = make({{kind.value_kind|array|go_type}}, len(keys{{le
vel}})) | |
59 for i, key := range keys{{level}} { | |
60 values{{level}}[i] = {{value}}[key] | |
61 } | |
62 } else { | |
63 for key{{level}}, value{{level}} := range {{value}} { | |
64 keys{{level}} = append(keys{{level}}, key{{level}}) | |
65 values{{level}} = append(values{{level}}, value{{level}}) | |
66 } | |
67 } | |
68 {{encode('keys'~level, kind.key_kind|array, level+1)|tab_indent()}} | |
69 {{encode('values'~level, kind.value_kind|array, level+1)|tab_indent()}} | |
70 } | |
71 if err := encoder.Finish(); err != nil { | |
72 return err | |
73 } | |
74 {% elif kind|is_enum %} | |
75 if err := encoder.WriteInt32(int32({{value}})); err != nil { | |
76 return err | |
77 } | |
78 {% elif kind|is_interface %} | |
79 if err := encoder.WriteInterface({{value}}.PassMessagePipe()); err != nil { | |
80 return err | |
81 } | |
82 {% elif kind|is_interface_request %} | |
83 if err := encoder.WriteHandle({{value}}.PassMessagePipe()); err != nil { | |
84 return err | |
85 } | |
86 {% else %} | |
87 if err := encoder.Write{{kind|encode_suffix}}({{value}}); err != nil { | |
88 return err | |
89 } | |
90 {% endif %} | |
91 {% endmacro %} | |
92 | |
93 | |
94 | |
95 {% macro decode(value, kind, level=0) %} | |
96 {% if kind|is_pointer %} | |
97 pointer{{level}}, err := decoder.ReadPointer() | |
98 if err != nil { | |
99 return err | |
100 } | |
101 if pointer{{level}} == 0 { | |
102 {% if kind|is_nullable %} | |
103 {{value}} = nil | |
104 } else { | |
105 {{value}} = new({{kind|go_type(False)}}) | |
106 {{decodePointerValue('(*'~value~')', kind, level)|tab_indent()}} | |
107 } | |
108 {% else %} | |
109 return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpe
cted null pointer"} | |
110 } else { | |
111 {{decodePointerValue(value, kind, level)|tab_indent()}} | |
112 } | |
113 {% endif %} | |
114 {% elif kind|is_union %} | |
115 var err error | |
116 {% set decoding_function = ('Decode'~ kind|unqualified_name)|qualified(kind|pa
ckage) %} | |
117 {{value}}, err = {{decoding_function}}(decoder) | |
118 if err != nil { | |
119 return err | |
120 } | |
121 {% if not kind|is_nullable %} | |
122 if {{value}} == nil { | |
123 return &bindings.ValidationError{bindings.UnexpectedNullUnion, "unexpect
ed null union"} | |
124 } | |
125 {% endif %} | |
126 {% elif kind|is_handle or kind|is_interface %} | |
127 handle{{level}}, err := decoder.Read{{kind|decode_suffix}}() | |
128 if err != nil { | |
129 return err | |
130 } | |
131 if handle{{level}}.IsValid() { | |
132 {% if kind|is_interface or kind|is_interface_request %} | |
133 handleOwner := bindings.NewMessagePipeHandleOwner(handle{{level}}) | |
134 {{value}} = {% if kind|is_nullable %}&{% endif %}{{kind|go_type(False)}}
{handleOwner} | |
135 {% else %} | |
136 {{value}} = {% if kind|is_nullable %}&{% endif %}handle{{level}} | |
137 {% endif %} | |
138 } else { | |
139 {% if kind|is_nullable %} | |
140 {{value}} = nil | |
141 {% else %} | |
142 return &bindings.ValidationError{bindings.UnexpectedInvalidHandle, "unex
pected invalid handle"} | |
143 {% endif %} | |
144 } | |
145 {% elif kind|is_enum %} | |
146 value{{level}}, err := decoder.Read{{kind|decode_suffix}}() | |
147 if err != nil { | |
148 return err | |
149 } | |
150 {{value}} = {% if kind|is_nullable %}&{% endif %}{{kind|go_type(False)}}(value{{
level}}) | |
151 {% else %} | |
152 value{{level}}, err := decoder.Read{{kind|decode_suffix}}() | |
153 if err != nil { | |
154 return err | |
155 } | |
156 {{value}} = {% if kind|is_nullable %}&{% endif %}value{{level}} | |
157 {% endif %} | |
158 {% endmacro %} | |
159 | |
160 | |
161 | |
162 {% macro decodePointerValue(value, kind, level=0) %} | |
163 {% if kind|is_struct %} | |
164 if err := {{value}}.Decode(decoder); err != nil { | |
165 return err | |
166 } | |
167 {% elif kind|is_array %} | |
168 len{{level}}, err := decoder.StartArray({{kind.kind|bit_size}}) | |
169 if err != nil { | |
170 return err | |
171 } | |
172 {% if kind.length %} | |
173 if len{{level}} != {{kind.length}} { | |
174 return &bindings.ValidationError{bindings.UnexpectedArrayHeader, | |
175 fmt.Sprintf("invalid array length: expected %d, got %d", {{kind.
length}}, len{{level}}), | |
176 } | |
177 } | |
178 {% else %} | |
179 {{value}} = make({{kind|go_type(False)}}, len{{level}}) | |
180 {% endif %} | |
181 for i{{level}} := uint32(0); i{{level}} < len{{level}}; i{{level}}++ { | |
182 {{decode(value~'[i'~level~']', kind.kind, level+1)|tab_indent()}} | |
183 } | |
184 if err := decoder.Finish(); err != nil { | |
185 return err | |
186 } | |
187 {% elif kind|is_map %} | |
188 if err := decoder.StartMap(); err != nil { | |
189 return err | |
190 } | |
191 var keys{{level}} {{kind.key_kind|array|go_type}} | |
192 { | |
193 {{decode('keys'~level, kind.key_kind|array, level+1)|tab_indent()}} | |
194 } | |
195 var values{{level}} {{kind.value_kind|array|go_type}} | |
196 { | |
197 {{decode('values'~level, kind.value_kind|array, level+1)|tab_indent()}} | |
198 } | |
199 if len(keys{{level}}) != len(values{{level}}) { | |
200 return &bindings.ValidationError{bindings.DifferentSizedArraysInMap, | |
201 fmt.Sprintf("Number of keys %d is different from number of value
s %d", len(keys{{level}}), len(values{{level}})), | |
202 } | |
203 } | |
204 if err := decoder.Finish(); err != nil { | |
205 return err | |
206 } | |
207 len{{level}} := len(keys{{level}}) | |
208 map{{level}} := make({{kind|go_type(False)}}) | |
209 for i{{level}} := 0; i{{level}} < len{{level}}; i{{level}}++ { | |
210 map{{level}}[keys{{level}}[i{{level}}]] = values{{level}}[i{{level}}] | |
211 } | |
212 {{value}} = map{{level}} | |
213 {% else %} | |
214 value{{level}}, err := decoder.Read{{kind|decode_suffix}}() | |
215 if err != nil { | |
216 return err | |
217 } | |
218 {{value}} = value{{level}} | |
219 {% endif %} | |
220 {% endmacro %} | |
OLD | NEW |