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

cborrs/
cbordetver.rs
