cborrs/
cbordetver.rs

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 ite: u8 =
109        if ty == cbor_det_int_kind::UInt64
110        { crate::cbordetveraux::cbor_major_type_uint64 }
111        else
112        { crate::cbordetveraux::cbor_major_type_neg_int64 };
113    let resi: crate::cbordetveraux::cbor_int =
114        crate::cbordetveraux::cbor_int
115        {
116            cbor_int_type: ite,
117            cbor_int_size: (crate::cbordetveraux::mk_raw_uint64(v)).size,
118            cbor_int_value: (crate::cbordetveraux::mk_raw_uint64(v)).value
119        };
120    crate::cbordetveraux::cbor_raw::CBOR_Case_Int { v: resi }
121}
122
123#[derive(PartialEq, Clone, Copy)]
124pub enum cbor_det_string_kind
125{
126    ByteString,
127    TextString
128}
129
130pub fn cbor_impl_utf8_correct(s: &[u8]) -> bool { crate::cbordetveraux::impl_correct(s) }
131
132pub fn cbor_det_mk_string <'a>(ty: cbor_det_string_kind, s: &'a [u8]) ->
133    option__CBOR_Pulse_Raw_Type_cbor_raw
134    <'a>
135{
136    if s.len() > 18446744073709551615u64 as usize
137    { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
138    else
139    {
140        let correct: bool =
141            if ty == cbor_det_string_kind::TextString { cbor_impl_utf8_correct(s) } else { true };
142        if correct
143        {
144            let len64: crate::cbordetveraux::raw_uint64 =
145                crate::cbordetveraux::mk_raw_uint64(s.len() as u64);
146            let ite: u8 =
147                if ty == cbor_det_string_kind::ByteString
148                { crate::cbordetveraux::cbor_major_type_byte_string }
149                else
150                { crate::cbordetveraux::cbor_major_type_text_string };
151            let ress: crate::cbordetveraux::cbor_string =
152                crate::cbordetveraux::cbor_string
153                { cbor_string_type: ite, cbor_string_size: len64.size, cbor_string_ptr: s };
154            let res: crate::cbordetveraux::cbor_raw =
155                crate::cbordetveraux::cbor_raw::CBOR_Case_String { v: ress };
156            option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res }
157        }
158        else
159        { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
160    }
161}
162
163pub fn cbor_det_mk_tagged <'a>(tag: u64, r: &'a [crate::cbordetveraux::cbor_raw <'a>]) ->
164    crate::cbordetveraux::cbor_raw
165    <'a>
166{
167    let tag64: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(tag);
168    let res·: crate::cbordetveraux::cbor_tagged =
169        crate::cbordetveraux::cbor_tagged { cbor_tagged_tag: tag64, cbor_tagged_ptr: r };
170    crate::cbordetveraux::cbor_raw::CBOR_Case_Tagged { v: res· }
171}
172
173pub type cbor_det_map_entry <'a> = crate::cbordetveraux::cbor_map_entry <'a>;
174
175pub fn cbor_det_mk_map_entry <'a>(
176    xk: crate::cbordetveraux::cbor_raw <'a>,
177    xv: crate::cbordetveraux::cbor_raw <'a>
178) ->
179    crate::cbordetveraux::cbor_map_entry
180    <'a>
181{ crate::cbordetveraux::cbor_mk_map_entry(xk, xv) }
182
183pub fn cbor_det_mk_array <'a>(a: &'a [crate::cbordetveraux::cbor_raw <'a>]) ->
184    option__CBOR_Pulse_Raw_Type_cbor_raw
185    <'a>
186{
187    if a.len() > 18446744073709551615u64 as usize
188    { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
189    else
190    {
191        let len64: crate::cbordetveraux::raw_uint64 =
192            crate::cbordetveraux::mk_raw_uint64(a.len() as u64);
193        let res·: crate::cbordetveraux::cbor_array =
194            crate::cbordetveraux::cbor_array
195            { cbor_array_length_size: len64.size, cbor_array_ptr: a };
196        let res: crate::cbordetveraux::cbor_raw =
197            crate::cbordetveraux::cbor_raw::CBOR_Case_Array { v: res· };
198        option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res }
199    }
200}
201
202pub fn cbor_det_mk_map <'a>(a: &'a mut [crate::cbordetveraux::cbor_map_entry <'a>]) ->
203    option__CBOR_Pulse_Raw_Type_cbor_raw
204    <'a>
205{
206    let mut dest: [crate::cbordetveraux::cbor_raw; 1] =
207        [crate::cbordetveraux::dummy_cbor_det_t(); 1usize];
208    let bres: bool =
209        if a.len() > 18446744073709551615u64 as usize
210        { false }
211        else
212        {
213            let correct: bool = crate::cbordetveraux::cbor_raw_sort(a);
214            if correct
215            {
216                let raw_len: crate::cbordetveraux::raw_uint64 =
217                    crate::cbordetveraux::mk_raw_uint64(a.len() as u64);
218                let res·: crate::cbordetveraux::cbor_map =
219                    crate::cbordetveraux::cbor_map
220                    { cbor_map_length_size: raw_len.size, cbor_map_ptr: a };
221                let res: crate::cbordetveraux::cbor_raw =
222                    crate::cbordetveraux::cbor_raw::CBOR_Case_Map { v: res· };
223                (&mut dest)[0] = res;
224                true
225            }
226            else
227            { false }
228        };
229    if bres
230    {
231        let res: crate::cbordetveraux::cbor_raw = (&dest)[0];
232        option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res }
233    }
234    else
235    { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
236}
237
238pub fn cbor_det_equal(x1: crate::cbordetveraux::cbor_raw, x2: crate::cbordetveraux::cbor_raw) ->
239    bool
240{
241    let comp: i16 = crate::cbordetveraux::impl_cbor_compare(x1, x2);
242    comp == 0i16
243}
244
245pub fn cbor_det_major_type(x: crate::cbordetveraux::cbor_raw) -> u8
246{ crate::cbordetveraux::impl_major_type(x) }
247
248pub type cbor_det_array <'a> = crate::cbordetveraux::cbor_raw <'a>;
249
250pub type cbor_det_map <'a> = crate::cbordetveraux::cbor_raw <'a>;
251
252#[derive(PartialEq, Clone, Copy)]
253enum cbor_det_view_tags
254{
255    Int64,
256    String,
257    Array,
258    Map,
259    Tagged,
260    SimpleValue
261}
262
263#[derive(PartialEq, Clone, Copy)]
264pub enum cbor_det_view <'a>
265{
266    Int64 { kind: cbor_det_int_kind, value: u64 },
267    String { kind: cbor_det_string_kind, payload: &'a [u8] },
268    Array { _0: crate::cbordetveraux::cbor_raw <'a> },
269    Map { _0: crate::cbordetveraux::cbor_raw <'a> },
270    Tagged { tag: u64, payload: crate::cbordetveraux::cbor_raw <'a> },
271    SimpleValue { _0: u8 }
272}
273
274pub fn cbor_det_destruct <'a>(c: crate::cbordetveraux::cbor_raw <'a>) -> cbor_det_view <'a>
275{
276    let ty: u8 = cbor_det_major_type(c);
277    if
278    ty == crate::cbordetveraux::cbor_major_type_uint64
279    ||
280    ty == crate::cbordetveraux::cbor_major_type_neg_int64
281    {
282        let k: cbor_det_int_kind =
283            if ty == crate::cbordetveraux::cbor_major_type_uint64
284            { cbor_det_int_kind::UInt64 }
285            else
286            { cbor_det_int_kind::NegInt64 };
287        let _letpattern: crate::cbordetveraux::cbor_raw = c;
288        let res: crate::cbordetveraux::raw_uint64 =
289            match _letpattern
290            {
291                crate::cbordetveraux::cbor_raw::CBOR_Case_Int { v: c· } =>
292                  crate::cbordetveraux::raw_uint64
293                  { size: c·.cbor_int_size, value: c·.cbor_int_value },
294                _ => panic!("Incomplete pattern matching")
295            };
296        let i: u64 = res.value;
297        cbor_det_view::Int64 { kind: k, value: i }
298    }
299    else if
300    ty == crate::cbordetveraux::cbor_major_type_byte_string
301    ||
302    ty == crate::cbordetveraux::cbor_major_type_text_string
303    {
304        let k: cbor_det_string_kind =
305            if ty == crate::cbordetveraux::cbor_major_type_byte_string
306            { cbor_det_string_kind::ByteString }
307            else
308            { cbor_det_string_kind::TextString };
309        let _letpattern: crate::cbordetveraux::cbor_raw = c;
310        let s: &[u8] =
311            match _letpattern
312            {
313                crate::cbordetveraux::cbor_raw::CBOR_Case_String { v: c· } => c·.cbor_string_ptr,
314                _ => panic!("Incomplete pattern matching")
315            };
316        cbor_det_view::String { kind: k, payload: s }
317    }
318    else if ty == crate::cbordetveraux::cbor_major_type_array
319    {
320        let res: crate::cbordetveraux::cbor_raw = c;
321        cbor_det_view::Array { _0: res }
322    }
323    else if ty == crate::cbordetveraux::cbor_major_type_map
324    {
325        let res: crate::cbordetveraux::cbor_raw = c;
326        cbor_det_view::Map { _0: res }
327    }
328    else if ty == crate::cbordetveraux::cbor_major_type_tagged
329    {
330        let res: crate::cbordetveraux::raw_uint64 =
331            match c
332            {
333                crate::cbordetveraux::cbor_raw::CBOR_Case_Tagged { v: c· } => c·.cbor_tagged_tag,
334                crate::cbordetveraux::cbor_raw::CBOR_Case_Serialized_Tagged { v: c· } =>
335                  c·.cbor_serialized_header,
336                _ => panic!("Incomplete pattern matching")
337            };
338        let tag: u64 = res.value;
339        let payload: crate::cbordetveraux::cbor_raw =
340            crate::cbordetveraux::cbor_match_tagged_get_payload(c);
341        cbor_det_view::Tagged { tag, payload }
342    }
343    else
344    {
345        let _letpattern: crate::cbordetveraux::cbor_raw = c;
346        let i: u8 =
347            match _letpattern
348            {
349                crate::cbordetveraux::cbor_raw::CBOR_Case_Simple { v: res } => res,
350                _ => panic!("Incomplete pattern matching")
351            };
352        cbor_det_view::SimpleValue { _0: i }
353    }
354}
355
356pub fn cbor_det_get_array_length(x: crate::cbordetveraux::cbor_raw) -> u64
357{
358    let res: crate::cbordetveraux::raw_uint64 =
359        match x
360        {
361            crate::cbordetveraux::cbor_raw::CBOR_Case_Array { v: c· } =>
362              crate::cbordetveraux::raw_uint64
363              { size: c·.cbor_array_length_size, value: (c·.cbor_array_ptr).len() as u64 },
364            crate::cbordetveraux::cbor_raw::CBOR_Case_Serialized_Array { v: c· } =>
365              c·.cbor_serialized_header,
366            _ => panic!("Incomplete pattern matching")
367        };
368    res.value
369}
370
371pub type cbor_det_array_iterator_t <'a> =
372crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw <'a>;
373
374pub fn cbor_det_array_iterator_start <'a>(x: crate::cbordetveraux::cbor_raw <'a>) ->
375    crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw
376    <'a>
377{ crate::cbordetveraux::cbor_array_iterator_init(x) }
378
379pub fn cbor_det_array_iterator_is_empty(
380    x: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw
381) ->
382    bool
383{ crate::cbordetveraux::cbor_array_iterator_is_empty(x) }
384
385pub fn cbor_det_array_iterator_next <'b, 'a>(
386    x: &'b mut [crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw <'a>]
387) ->
388    crate::cbordetveraux::cbor_raw
389    <'a>
390{ crate::cbordetveraux::cbor_array_iterator_next(x) }
391
392pub fn cbor_det_array_iterator_length(
393    x: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw
394) ->
395    u64
396{ crate::cbordetveraux::cbor_array_iterator_length(x) }
397
398pub fn cbor_det_array_iterator_truncate <'a>(
399    x: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw <'a>,
400    len: u64
401) ->
402    crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_raw
403    <'a>
404{ crate::cbordetveraux::cbor_array_iterator_truncate(x, len) }
405
406pub fn cbor_det_get_array_item <'a>(x: crate::cbordetveraux::cbor_raw <'a>, i: u64) ->
407    option__CBOR_Pulse_Raw_Type_cbor_raw
408    <'a>
409{
410    let len: u64 = cbor_det_get_array_length(x);
411    if i >= len
412    { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
413    else
414    {
415        let res: crate::cbordetveraux::cbor_raw = crate::cbordetveraux::cbor_array_item(x, i);
416        option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res }
417    }
418}
419
420pub fn cbor_det_map_length(x: crate::cbordetveraux::cbor_raw) -> u64
421{
422    let res: crate::cbordetveraux::raw_uint64 =
423        match x
424        {
425            crate::cbordetveraux::cbor_raw::CBOR_Case_Map { v: c· } =>
426              crate::cbordetveraux::raw_uint64
427              { size: c·.cbor_map_length_size, value: (c·.cbor_map_ptr).len() as u64 },
428            crate::cbordetveraux::cbor_raw::CBOR_Case_Serialized_Map { v: c· } =>
429              c·.cbor_serialized_header,
430            _ => panic!("Incomplete pattern matching")
431        };
432    res.value
433}
434
435pub type cbor_det_map_iterator_t <'a> =
436crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry <'a>;
437
438pub fn cbor_det_map_iterator_start <'a>(x: crate::cbordetveraux::cbor_raw <'a>) ->
439    crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry
440    <'a>
441{
442    let res: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry =
443        crate::cbordetveraux::cbor_map_iterator_init(x);
444    res
445}
446
447pub fn cbor_det_map_iterator_is_empty(
448    x: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry
449) ->
450    bool
451{ crate::cbordetveraux::cbor_map_iterator_is_empty(x) }
452
453pub fn cbor_det_map_iterator_next <'b, 'a>(
454    x: &'b mut [crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry <'a>]
455) ->
456    crate::cbordetveraux::cbor_map_entry
457    <'a>
458{ crate::cbordetveraux::cbor_map_iterator_next(x) }
459
460pub fn cbor_det_map_entry_key <'a>(x2: crate::cbordetveraux::cbor_map_entry <'a>) ->
461    crate::cbordetveraux::cbor_raw
462    <'a>
463{ x2.cbor_map_entry_key }
464
465pub fn cbor_det_map_entry_value <'a>(x2: crate::cbordetveraux::cbor_map_entry <'a>) ->
466    crate::cbordetveraux::cbor_raw
467    <'a>
468{ x2.cbor_map_entry_value }
469
470pub fn cbor_det_map_get <'a>(
471    x: crate::cbordetveraux::cbor_raw <'a>,
472    k: crate::cbordetveraux::cbor_raw <'a>
473) ->
474    option__CBOR_Pulse_Raw_Type_cbor_raw
475    <'a>
476{
477    let mut dest: [crate::cbordetveraux::cbor_raw; 1] = [k; 1usize];
478    let res: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry =
479        crate::cbordetveraux::cbor_map_iterator_init(x);
480    let i: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry = res;
481    let mut pi: [crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry; 1] =
482        [i; 1usize];
483    let mut pres: [option__CBOR_Pulse_Raw_Type_cbor_raw; 1] =
484        [option__CBOR_Pulse_Raw_Type_cbor_raw::None; 1usize];
485    let i_is_empty: bool = crate::cbordetveraux::cbor_map_iterator_is_empty(i);
486    let cont: bool = ! i_is_empty;
487    let mut pcont: [bool; 1] = [cont; 1usize];
488    while
489    (&pcont)[0]
490    {
491        let entry: crate::cbordetveraux::cbor_map_entry =
492            crate::cbordetveraux::cbor_map_iterator_next(&mut pi);
493        let key: crate::cbordetveraux::cbor_raw = entry.cbor_map_entry_key;
494        let comp: i16 = crate::cbordetveraux::impl_cbor_det_compare(key, k);
495        if comp == 0i16
496        {
497            let value: crate::cbordetveraux::cbor_raw = entry.cbor_map_entry_value;
498            (&mut pres)[0] = option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: value };
499            (&mut pcont)[0] = false
500        }
501        else if comp > 0i16
502        { (&mut pcont)[0] = false }
503        else
504        {
505            let i·: crate::cbordetveraux::cbor_raw_iterator__CBOR_Pulse_Raw_Type_cbor_map_entry =
506                (&pi)[0];
507            let is_empty: bool = crate::cbordetveraux::cbor_map_iterator_is_empty(i·);
508            let cont1: bool = ! is_empty;
509            (&mut pcont)[0] = cont1
510        }
511    };
512    let res0: option__CBOR_Pulse_Raw_Type_cbor_raw = (&pres)[0];
513    let bres: bool =
514        match res0
515        {
516            option__CBOR_Pulse_Raw_Type_cbor_raw::None => false,
517            option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: vres } =>
518              {
519                  (&mut dest)[0] = vres;
520                  true
521              },
522            _ => panic!("Incomplete pattern matching")
523        };
524    if bres
525    {
526        let res1: crate::cbordetveraux::cbor_raw = (&dest)[0];
527        option__CBOR_Pulse_Raw_Type_cbor_raw::Some { v: res1 }
528    }
529    else
530    { option__CBOR_Pulse_Raw_Type_cbor_raw::None }
531}
532
533pub fn cbor_det_serialize_string(ty: u8, off: u64, out: &mut [u8]) -> usize
534{
535    let roff: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(off);
536    let res: usize = crate::cbordetveraux::cbor_serialize_string(ty, roff, out);
537    res
538}
539
540pub fn cbor_det_serialize_tag(tag: u64, output: &mut [u8]) -> usize
541{
542    let tag·: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(tag);
543    crate::cbordetveraux::cbor_serialize_tag(tag·, output)
544}
545
546pub fn cbor_det_serialize_array(len: u64, out: &mut [u8], off: usize) -> usize
547{
548    let rlen: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(len);
549    crate::cbordetveraux::cbor_serialize_array(rlen, out, off)
550}
551
552pub fn cbor_det_serialize_map_insert(out: &mut [u8], off2: usize, off3: usize) -> bool
553{ crate::cbordetveraux::cbor_raw_map_insert(out, off2, off3) }
554
555pub fn cbor_det_serialize_map(len: u64, out: &mut [u8], off: usize) -> usize
556{
557    let rlen: crate::cbordetveraux::raw_uint64 = crate::cbordetveraux::mk_raw_uint64(len);
558    crate::cbordetveraux::cbor_serialize_map(rlen, out, off)
559}
560
561pub fn dummy_cbor_det_t <'a>() -> crate::cbordetveraux::cbor_raw <'a>
562{ crate::cbordetveraux::dummy_cbor_det_t() }
cborrs/cbordetver.rs

cborrs/
cbordetver.rs
