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

cborrs/
cbordetver.rs
