1#![allow(non_snake_case)]
2#![allow(non_upper_case_globals)]
3#![allow(non_camel_case_types)]
4#![allow(unused_assignments)]
5#![allow(unreachable_patterns)]
6
7pub type cbordet <'a> = crate::cbordetveraux::cbor_raw <'a>;
8
9pub fn cbor_det_reset_perm <'a>(x1: crate::cbordetveraux::cbor_raw <'a>) ->
10 crate::cbordetveraux::cbor_raw
11 <'a>
12{ crate::cbordetveraux::cbor_raw_reset_perm_tot(x1) }
13
14#[derive(PartialEq, Clone, Copy)]
15pub enum option__·CBOR_Pulse_Raw_Type_cbor_raw···Pulse_Lib_Slice_slice·uint8_t· <'a>
16{
17 None,
18 Some { v: (crate::cbordetveraux::cbor_raw <'a>, &'a [u8]) }
19}
20
21pub fn cbor_det_parse <'a>(input: &'a [u8]) ->
22 option__·CBOR_Pulse_Raw_Type_cbor_raw···Pulse_Lib_Slice_slice·uint8_t·
23 <'a>
24{
25 let len: usize = crate::cbordetveraux::cbor_validate_det(input);
26 if len == 0usize
27 { option__·CBOR_Pulse_Raw_Type_cbor_raw···Pulse_Lib_Slice_slice·uint8_t·::None }
28 else
29 {
30 let s·: (&[u8], &[u8]) = input.split_at(len);
31 let _letpattern: (&[u8], &[u8]) =
32 {
33 let s1: &[u8] = s·.0;
34 let s2: &[u8] = s·.1;
35 (s1,s2)
36 };
37 let input2: &[u8] = _letpattern.0;
38 let rem: &[u8] = _letpattern.1;
39 let len1: usize = input2.len();
40 let res: crate::cbordetveraux::cbor_raw = crate::cbordetveraux::cbor_parse(input2, len1);
41 option__·CBOR_Pulse_Raw_Type_cbor_raw···Pulse_Lib_Slice_slice·uint8_t·::Some
42 { v: (res,rem) }
43 }
44}
45
46#[derive(PartialEq, Clone, Copy)]
47pub enum option__size_t
48{
49 None,
50 Some { v: usize }
51}
52
53pub fn cbor_det_size(x: crate::cbordetveraux::cbor_raw, bound: usize) -> option__size_t
54{
55 let size: usize = crate::cbordetveraux::cbor_size(x, bound);
56 if size == 0usize { option__size_t::None } else { option__size_t::Some { v: size } }
57}
58
59pub fn cbor_det_serialize(x: crate::cbordetveraux::cbor_raw, output: &mut [u8]) ->
60 option__size_t
61{
62 let len: usize = crate::cbordetveraux::cbor_size(x, output.len());
63 if len > 0usize
64 {
65 let _letpattern: (&mut [u8], &mut [u8]) = output.split_at_mut(len);
66 let out: &mut [u8] = _letpattern.0;
67 let _rem: &[u8] = _letpattern.1;
68 let len·: usize = crate::cbordetveraux::cbor_serialize(x, out);
69 option__size_t::Some { v: len· }
70 }
71 else
72 { option__size_t::None }
73}
74
75#[derive(PartialEq, Clone, Copy)]
76pub enum option__CBOR_Pulse_Raw_Type_cbor_raw <'a>
77{
78 None,
79 Some { v: crate::cbordetveraux::cbor_raw <'a> }
80}
81
82pub fn cbor_det_mk_simple_value <'a>(v: u8) -> option__CBOR_Pulse_Raw_Type_cbor_raw <'a>
83{
84 if
85 v <= crate::cbordetveraux::max_simple_value_additional_info
86 ||
87 crate::cbordetveraux::min_simple_value_long_argument <= v
88 {
89 let res: crate::cbordetveraux::cbor_raw =
90 crate::cbordetveraux::cbor_raw::CBOR_Case_Simple { v };
91 option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res }
92 }
93 else
94 { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
95}
96
97#[derive(PartialEq, Clone, Copy)]
98pub enum cbor_det_int_kind
99{
100 UInt64,
101 NegInt64
102}
103
104pub fn cbor_det_mk_int64 <'a>(ty: cbor_det_int_kind, v: u64) ->
105 crate::cbordetveraux::cbor_raw
106 <'a>
107{
108 let resi: crate::cbordetveraux::cbor_int =
109 crate::cbordetveraux::cbor_int
110 {
111 cbor_int_type:
112 if ty == cbor_det_int_kind::UInt64
113 { crate::cbordetveraux::cbor_major_type_uint64 }
114 else
115 { crate::cbordetveraux::cbor_major_type_neg_int64 },
116 cbor_int_size: (crate::cbordetveraux::mk_raw_uint64(v)).size,
117 cbor_int_value: (crate::cbordetveraux::mk_raw_uint64(v)).value
118 };
119 crate::cbordetveraux::cbor_raw::CBOR_Case_Int { v: resi }
120}
121
122#[derive(PartialEq, Clone, Copy)]
123pub enum cbor_det_string_kind
124{
125 ByteString,
126 TextString
127}
128
129pub fn cbor_impl_utf8_correct(s: &[u8]) -> bool { crate::cbordetveraux::impl_correct(s) }
130
131pub fn cbor_det_mk_string <'a>(ty: cbor_det_string_kind, s: &'a [u8]) ->
132 option__CBOR_Pulse_Raw_Type_cbor_raw
133 <'a>
134{
135 let q1: usize = s.len().wrapping_div(32768usize);
136 let q2: usize = q1.wrapping_div(32768usize);
137 let q3: usize = q2.wrapping_div(32768usize);
138 let q4: usize = q3.wrapping_div(32768usize);
139 let __anf0: bool = q4 < 16usize;
140 if ! __anf0
141 { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
142 else
143 {
144 let correct: bool =
145 if ty == cbor_det_string_kind::TextString { cbor_impl_utf8_correct(s) } else { true };
146 if correct
147 {
148 let len64: crate::cbordetveraux::raw_uint64 =
149 crate::cbordetveraux::mk_raw_uint64(s.len() as u64);
150 let ress: crate::cbordetveraux::cbor_string =
151 crate::cbordetveraux::cbor_string
152 {
153 cbor_string_type:
154 if ty == cbor_det_string_kind::ByteString
155 { crate::cbordetveraux::cbor_major_type_byte_string }
156 else
157 { crate::cbordetveraux::cbor_major_type_text_string },
158 cbor_string_size: len64.size,
159 cbor_string_ptr: s
160 };
161 let res: crate::cbordetveraux::cbor_raw =
162 crate::cbordetveraux::cbor_raw::CBOR_Case_String { v: ress };
163 option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res }
164 }
165 else
166 { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
167 }
168}
169
170pub fn cbor_det_mk_tagged <'a>(tag: u64, r: &'a [crate::cbordetveraux::cbor_raw <'a>]) ->
171 crate::cbordetveraux::cbor_raw
172 <'a>
173{
174 let tag64: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(tag);
175 let res·: crate::cbordetveraux::cbor_tagged =
176 crate::cbordetveraux::cbor_tagged { cbor_tagged_tag: tag64, cbor_tagged_ptr: r };
177 crate::cbordetveraux::cbor_raw::CBOR_Case_Tagged { v: res· }
178}
179
180pub type cbor_det_map_entry <'a> = crate::cbordetveraux::cbor_map_entry <'a>;
181
182pub fn cbor_det_mk_map_entry <'a>(
183 xk: crate::cbordetveraux::cbor_raw <'a>,
184 xv: crate::cbordetveraux::cbor_raw <'a>
185) ->
186 crate::cbordetveraux::cbor_map_entry
187 <'a>
188{ crate::cbordetveraux::cbor_mk_map_entry(xk, xv) }
189
190pub fn cbor_det_mk_array <'a>(a: &'a [crate::cbordetveraux::cbor_raw <'a>]) ->
191 option__CBOR_Pulse_Raw_Type_cbor_raw
192 <'a>
193{
194 let q1: usize = a.len().wrapping_div(32768usize);
195 let q2: usize = q1.wrapping_div(32768usize);
196 let q3: usize = q2.wrapping_div(32768usize);
197 let q4: usize = q3.wrapping_div(32768usize);
198 let __anf0: bool = q4 < 16usize;
199 if ! __anf0
200 { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
201 else
202 {
203 let len64: crate::cbordetveraux::raw_uint64 =
204 crate::cbordetveraux::mk_raw_uint64(a.len() as u64);
205 let res·: crate::cbordetveraux::cbor_array =
206 crate::cbordetveraux::cbor_array
207 { cbor_array_length_size: len64.size, cbor_array_ptr: a };
208 let res: crate::cbordetveraux::cbor_raw =
209 crate::cbordetveraux::cbor_raw::CBOR_Case_Array { v: res· };
210 option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res }
211 }
212}
213
214pub fn cbor_det_mk_map <'a>(a: &'a mut [crate::cbordetveraux::cbor_map_entry <'a>]) ->
215 option__CBOR_Pulse_Raw_Type_cbor_raw
216 <'a>
217{
218 let mut dest: [crate::cbordetveraux::cbor_raw; 1] =
219 [crate::cbordetveraux::dummy_cbor_det_t(); 1usize];
220 let q1: usize = a.len().wrapping_div(32768usize);
221 let q2: usize = q1.wrapping_div(32768usize);
222 let q3: usize = q2.wrapping_div(32768usize);
223 let q4: usize = q3.wrapping_div(32768usize);
224 let __anf0: bool = q4 < 16usize;
225 let bres: bool =
226 if ! __anf0
227 { false }
228 else
229 {
230 let correct: bool = crate::cbordetveraux::cbor_raw_sort(a);
231 if correct
232 {
233 let raw_len: crate::cbordetveraux::raw_uint64 =
234 crate::cbordetveraux::mk_raw_uint64(a.len() as u64);
235 let res·: crate::cbordetveraux::cbor_map =
236 crate::cbordetveraux::cbor_map
237 { cbor_map_length_size: raw_len.size, cbor_map_ptr: a };
238 let res: crate::cbordetveraux::cbor_raw =
239 crate::cbordetveraux::cbor_raw::CBOR_Case_Map { v: res· };
240 (&mut dest)[0] = res;
241 true
242 }
243 else
244 { false }
245 };
246 if bres
247 {
248 let res: crate::cbordetveraux::cbor_raw = (&dest)[0];
249 option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res }
250 }
251 else
252 { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
253}
254
255pub fn cbor_det_equal(x1: crate::cbordetveraux::cbor_raw, x2: crate::cbordetveraux::cbor_raw) ->
256 bool
257{
258 let comp: i16 = crate::cbordetveraux::impl_cbor_compare(x1, x2);
259 comp == 0i16
260}
261
262pub fn cbor_det_major_type(x: crate::cbordetveraux::cbor_raw) -> u8
263{ crate::cbordetveraux::impl_major_type(x) }
264
265pub type cbor_det_array <'a> = crate::cbordetveraux::cbor_raw <'a>;
266
267pub type cbor_det_map <'a> = crate::cbordetveraux::cbor_raw <'a>;
268
269#[derive(PartialEq, Clone, Copy)]
270enum cbor_det_view_tags
271{
272 Int64,
273 String,
274 Array,
275 Map,
276 Tagged,
277 SimpleValue
278}
279
280#[derive(PartialEq, Clone, Copy)]
281pub enum cbor_det_view <'a>
282{
283 Int64 { kind: cbor_det_int_kind, value: u64 },
284 String { kind: cbor_det_string_kind, payload: &'a [u8] },
285 Array { _0: crate::cbordetveraux::cbor_raw <'a> },
286 Map { _0: crate::cbordetveraux::cbor_raw <'a> },
287 Tagged { tag: u64, payload: crate::cbordetveraux::cbor_raw <'a> },
288 SimpleValue { _0: u8 }
289}
290
291pub fn cbor_det_destruct <'a>(c: crate::cbordetveraux::cbor_raw <'a>) -> cbor_det_view <'a>
292{
293 let ty: u8 = cbor_det_major_type(c);
294 if
295 ty == crate::cbordetveraux::cbor_major_type_uint64
296 ||
297 ty == crate::cbordetveraux::cbor_major_type_neg_int64
298 {
299 let k: cbor_det_int_kind =
300 if ty == crate::cbordetveraux::cbor_major_type_uint64
301 { cbor_det_int_kind::UInt64 }
302 else
303 { cbor_det_int_kind::NegInt64 };
304 let _letpattern: crate::cbordetveraux::cbor_raw = c;
305 let res: crate::cbordetveraux::raw_uint64 =
306 match _letpattern
307 {
308 crate::cbordetveraux::cbor_raw::CBOR_Case_Int { v: c· } =>
309 crate::cbordetveraux::raw_uint64
310 { size: c·.cbor_int_size, value: c·.cbor_int_value },
311 _ => panic!("Incomplete pattern matching")
312 };
313 let i: u64 = res.value;
314 cbor_det_view::Int64 { kind: k, value: i }
315 }
316 else if
317 ty == crate::cbordetveraux::cbor_major_type_byte_string
318 ||
319 ty == crate::cbordetveraux::cbor_major_type_text_string
320 {
321 let k: cbor_det_string_kind =
322 if ty == crate::cbordetveraux::cbor_major_type_byte_string
323 { cbor_det_string_kind::ByteString }
324 else
325 { cbor_det_string_kind::TextString };
326 let _letpattern: crate::cbordetveraux::cbor_raw = c;
327 let s: &[u8] =
328 match _letpattern
329 {
330 crate::cbordetveraux::cbor_raw::CBOR_Case_String { v: c· } => c·.cbor_string_ptr,
331 _ => panic!("Incomplete pattern matching")
332 };
333 cbor_det_view::String { kind: k, payload: s }
334 }
335 else if ty == crate::cbordetveraux::cbor_major_type_array
336 {
337 let res: crate::cbordetveraux::cbor_raw = c;
338 cbor_det_view::Array { _0: res }
339 }
340 else if ty == crate::cbordetveraux::cbor_major_type_map
341 {
342 let res: crate::cbordetveraux::cbor_raw = c;
343 cbor_det_view::Map { _0: res }
344 }
345 else if ty == crate::cbordetveraux::cbor_major_type_tagged
346 {
347 let res: crate::cbordetveraux::raw_uint64 =
348 match c
349 {
350 crate::cbordetveraux::cbor_raw::CBOR_Case_Tagged { v: c· } => c·.cbor_tagged_tag,
351 crate::cbordetveraux::cbor_raw::CBOR_Case_Serialized_Tagged { v: c· } =>
352 c·.cbor_serialized_header,
353 _ => panic!("Incomplete pattern matching")
354 };
355 let tag: u64 = res.value;
356 let payload: crate::cbordetveraux::cbor_raw =
357 crate::cbordetveraux::cbor_match_tagged_get_payload(c);
358 cbor_det_view::Tagged { tag, payload }
359 }
360 else
361 {
362 let _letpattern: crate::cbordetveraux::cbor_raw = c;
363 let i: u8 =
364 match _letpattern
365 {
366 crate::cbordetveraux::cbor_raw::CBOR_Case_Simple { v: res } => res,
367 _ => panic!("Incomplete pattern matching")
368 };
369 cbor_det_view::SimpleValue { _0: i }
370 }
371}
372
373pub fn cbor_det_get_array_length(x: crate::cbordetveraux::cbor_raw) -> u64
374{
375 let res: crate::cbordetveraux::raw_uint64 =
376 match x
377 {
378 crate::cbordetveraux::cbor_raw::CBOR_Case_Array { v: c· } =>
379 crate::cbordetveraux::raw_uint64
380 { size: c·.cbor_array_length_size, value: (c·.cbor_array_ptr).len() as u64 },
381 crate::cbordetveraux::cbor_raw::CBOR_Case_Serialized_Array { v: c· } =>
382 c·.cbor_serialized_header,
383 _ => panic!("Incomplete pattern matching")
384 };
385 res.value
386}
387
388pub type cbor_det_array_iterator_t <'a> =
389crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw <'a>;
390
391pub fn cbor_det_array_iterator_start <'a>(x: crate::cbordetveraux::cbor_raw <'a>) ->
392 crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw
393 <'a>
394{ crate::cbordetveraux::cbor_array_iterator_init(x) }
395
396pub fn cbor_det_array_iterator_is_empty(
397 x: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw
398) ->
399 bool
400{ crate::cbordetveraux::cbor_array_iterator_is_empty(x) }
401
402pub fn cbor_det_array_iterator_next <'b, 'a>(
403 x: &'b mut [crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw <'a>]
404) ->
405 crate::cbordetveraux::cbor_raw
406 <'a>
407{ crate::cbordetveraux::cbor_array_iterator_next(x) }
408
409pub fn cbor_det_array_iterator_length(
410 x: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw
411) ->
412 u64
413{ crate::cbordetveraux::cbor_array_iterator_length(x) }
414
415pub fn cbor_det_array_iterator_truncate <'a>(
416 x: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw <'a>,
417 len: u64
418) ->
419 crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw
420 <'a>
421{ crate::cbordetveraux::cbor_array_iterator_truncate(x, len) }
422
423pub fn cbor_det_get_array_item <'a>(x: crate::cbordetveraux::cbor_raw <'a>, i: u64) ->
424 option__CBOR_Pulse_Raw_Type_cbor_raw
425 <'a>
426{
427 let len: u64 = cbor_det_get_array_length(x);
428 if i >= len
429 { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
430 else
431 {
432 let res: crate::cbordetveraux::cbor_raw = crate::cbordetveraux::cbor_array_item(x, i);
433 option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res }
434 }
435}
436
437pub fn cbor_det_map_length(x: crate::cbordetveraux::cbor_raw) -> u64
438{
439 let res: crate::cbordetveraux::raw_uint64 =
440 match x
441 {
442 crate::cbordetveraux::cbor_raw::CBOR_Case_Map { v: c· } =>
443 crate::cbordetveraux::raw_uint64
444 { size: c·.cbor_map_length_size, value: (c·.cbor_map_ptr).len() as u64 },
445 crate::cbordetveraux::cbor_raw::CBOR_Case_Serialized_Map { v: c· } =>
446 c·.cbor_serialized_header,
447 _ => panic!("Incomplete pattern matching")
448 };
449 res.value
450}
451
452pub type cbor_det_map_iterator_t <'a> =
453crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry <'a>;
454
455pub fn cbor_det_map_iterator_start <'a>(x: crate::cbordetveraux::cbor_raw <'a>) ->
456 crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry
457 <'a>
458{
459 let res: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry =
460 crate::cbordetveraux::cbor_map_iterator_init(x);
461 res
462}
463
464pub fn cbor_det_map_iterator_is_empty(
465 x: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry
466) ->
467 bool
468{ crate::cbordetveraux::cbor_map_iterator_is_empty(x) }
469
470pub fn cbor_det_map_iterator_next <'b, 'a>(
471 x: &'b mut [crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry <'a>]
472) ->
473 crate::cbordetveraux::cbor_map_entry
474 <'a>
475{ crate::cbordetveraux::cbor_map_iterator_next(x) }
476
477pub fn cbor_det_map_entry_key <'a>(x2: crate::cbordetveraux::cbor_map_entry <'a>) ->
478 crate::cbordetveraux::cbor_raw
479 <'a>
480{ x2.cbor_map_entry_key }
481
482pub fn cbor_det_map_entry_value <'a>(x2: crate::cbordetveraux::cbor_map_entry <'a>) ->
483 crate::cbordetveraux::cbor_raw
484 <'a>
485{ x2.cbor_map_entry_value }
486
487pub fn cbor_det_map_get <'a>(
488 x: crate::cbordetveraux::cbor_raw <'a>,
489 k: crate::cbordetveraux::cbor_raw <'a>
490) ->
491 option__CBOR_Pulse_Raw_Type_cbor_raw
492 <'a>
493{
494 let mut dest: [crate::cbordetveraux::cbor_raw; 1] = [k; 1usize];
495 let res: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry =
496 crate::cbordetveraux::cbor_map_iterator_init(x);
497 let i: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry = res;
498 let mut pi: [crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry; 1] =
499 [i; 1usize];
500 let mut pres: [option__CBOR_Pulse_Raw_Type_cbor_raw; 1] =
501 [option__CBOR_Pulse_Raw_Type_cbor_raw::None; 1usize];
502 let i_is_empty: bool = crate::cbordetveraux::cbor_map_iterator_is_empty(i);
503 let cont: bool = ! i_is_empty;
504 let mut pcont: [bool; 1] = [cont; 1usize];
505 while
506 (&pcont)[0]
507 {
508 let entry: crate::cbordetveraux::cbor_map_entry =
509 crate::cbordetveraux::cbor_map_iterator_next(&mut pi);
510 let key: crate::cbordetveraux::cbor_raw = entry.cbor_map_entry_key;
511 let comp: i16 = crate::cbordetveraux::impl_cbor_det_compare(key, k);
512 if comp == 0i16
513 {
514 let value: crate::cbordetveraux::cbor_raw = entry.cbor_map_entry_value;
515 (&mut pres)[0] = option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: value };
516 (&mut pcont)[0] = false
517 }
518 else if comp > 0i16
519 { (&mut pcont)[0] = false }
520 else
521 {
522 let i·: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry =
523 (&pi)[0];
524 let is_empty: bool = crate::cbordetveraux::cbor_map_iterator_is_empty(i·);
525 let cont1: bool = ! is_empty;
526 (&mut pcont)[0] = cont1
527 }
528 };
529 let res0: option__CBOR_Pulse_Raw_Type_cbor_raw = (&pres)[0];
530 let bres: bool =
531 match res0
532 {
533 option__CBOR_Pulse_Raw_Type_cbor_raw::None => false,
534 option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: vres } =>
535 {
536 (&mut dest)[0] = vres;
537 true
538 },
539 _ => panic!("Incomplete pattern matching")
540 };
541 if bres
542 {
543 let res1: crate::cbordetveraux::cbor_raw = (&dest)[0];
544 option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res1 }
545 }
546 else
547 { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
548}
549
550pub fn cbor_det_serialize_string(ty: u8, off: u64, out: &mut [u8]) -> usize
551{
552 let roff: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(off);
553 let res: usize = crate::cbordetveraux::cbor_serialize_string(ty, roff, out);
554 res
555}
556
557pub fn cbor_det_serialize_tag(tag: u64, output: &mut [u8]) -> usize
558{
559 let tag·: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(tag);
560 crate::cbordetveraux::cbor_serialize_tag(tag·, output)
561}
562
563pub fn cbor_det_serialize_array(len: u64, out: &mut [u8], off: usize) -> usize
564{
565 let rlen: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(len);
566 crate::cbordetveraux::cbor_serialize_array(rlen, out, off)
567}
568
569pub fn cbor_det_serialize_map_insert(out: &mut [u8], off2: usize, off3: usize) -> bool
570{ crate::cbordetveraux::cbor_raw_map_insert(out, off2, off3) }
571
572pub fn cbor_det_serialize_map(len: u64, out: &mut [u8], off: usize) -> usize
573{
574 let rlen: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(len);
575 crate::cbordetveraux::cbor_serialize_map(rlen, out, off)
576}
577
578pub fn dummy_cbor_det_t <'a>() -> crate::cbordetveraux::cbor_raw <'a>
579{ crate::cbordetveraux::dummy_cbor_det_t() }