rlink_buffer/
buffer.rs

1//! https://github.com/capnproto/capnproto-rust/blob/master/capnp/src/lib.rs
2
3use bytes::{Buf, BufMut, BytesMut};
4use std::hash::Hasher;
5use std::io::ErrorKind;
6
7pub mod types {
8    /// types: 0b[type]_[length_mod]
9    /// length = if length_mod == 0 then 0 else 2 << (length_mod -1) .
10    ///     eg: BOOL,I8,U8 = 0
11    ///         I16,U16 = 2 << (1-1) = 2
12    ///         I32,U32,F32 = 2 << (2-1) = 4
13    ///         I64,U64,F64 = 2 << (3-1) = 8
14    pub const BOOL: u8 = 0b0000_0000;
15    pub const I8: u8 = 0b0001_0000;
16    pub const U8: u8 = 0b0010_0000;
17    pub const I16: u8 = 0b0011_0001;
18    pub const U16: u8 = 0b0100_0001;
19    pub const I32: u8 = 0b0101_0010;
20    pub const U32: u8 = 0b0111_0010;
21    pub const I64: u8 = 0b1000_0011;
22    pub const U64: u8 = 0b1001_0011;
23    pub const F32: u8 = 0b1010_0010;
24    pub const F64: u8 = 0b1011_0011;
25    pub const BYTES: u8 = 0b1100_0000;
26    pub const STRING: u8 = BYTES;
27    // pub const BYTES: u8 = 0b1101_0000;
28    // pub const I = 0b1110;
29    // pub const I = 0b1111;
30
31    #[inline]
32    pub fn len(data_type: u8) -> u8 {
33        let length_mod = data_type & 0b0000_1111;
34        if length_mod == 0 {
35            1
36        } else {
37            2 << (length_mod - 1)
38        }
39    }
40}
41
42#[derive(Clone, Debug)]
43pub struct Buffer {
44    buf: BytesMut,
45    buf_len: usize,
46
47    /// field position index cache, build by `Writer` and for `Reader` fast read.
48    /// the field is not serialized and deserialized.
49    /// must be clear when some create operator such as `new`,`extend`,`reset` ..
50    field_pos_index: Vec<usize>,
51}
52
53impl Buffer {
54    pub fn new() -> Self {
55        Buffer {
56            buf: BytesMut::with_capacity(256),
57            buf_len: 0,
58            field_pos_index: vec![],
59        }
60    }
61
62    pub fn with_capacity(capacity: usize) -> Self {
63        Buffer {
64            buf: BytesMut::with_capacity(capacity),
65            buf_len: 0,
66            field_pos_index: vec![],
67        }
68    }
69
70    pub fn from(bytes: BytesMut) -> Self {
71        let buffer_len = bytes.len();
72        Buffer {
73            buf: bytes,
74            buf_len: buffer_len,
75            field_pos_index: vec![],
76        }
77    }
78
79    pub fn len(&self) -> usize {
80        self.buf_len
81    }
82
83    pub fn as_slice(&self) -> &[u8] {
84        self.buf.bytes()
85    }
86
87    pub fn extend(&mut self, other: &Buffer) -> Result<(), std::io::Error> {
88        self.field_pos_index.clear();
89
90        self.buf_len += other.buf_len;
91        self.buf.put_slice(other.as_slice());
92
93        Ok(())
94    }
95
96    pub fn as_reader<'a, 'b>(&'a mut self, data_types: &'b [u8]) -> BufferReader<'a, 'b> {
97        self.position_index_cache_check(data_types);
98
99        BufferReader::new(self, data_types)
100    }
101    pub fn as_writer<'a, 'b>(&'a mut self, data_types: &'b [u8]) -> BufferWriter<'a, 'b> {
102        self.position_index_cache_check(data_types);
103
104        BufferWriter::new(self, data_types)
105    }
106
107    fn position_index_cache_check(&mut self, data_types: &[u8]) {
108        if self.field_pos_index.len() == 0 && self.buf_len > 0 {
109            let mut field_start_pos = 0;
110            for index in 0..data_types.len() {
111                if field_start_pos > self.buf_len {
112                    panic!("read error");
113                }
114
115                self.field_pos_index.push(field_start_pos);
116                let data_type = data_types[index];
117                if data_type == types::BYTES {
118                    let len = self
119                        .buf
120                        .get(field_start_pos..field_start_pos + 4)
121                        .map(|x| unsafe { u32::from_le_bytes(*(x as *const _ as *const [_; 4])) })
122                        .unwrap();
123                    field_start_pos += (len + 4) as usize;
124                } else {
125                    let len = types::len(data_type);
126                    field_start_pos += len as usize;
127                }
128            }
129
130            if field_start_pos > self.buf_len {
131                panic!("read error");
132            }
133        }
134    }
135}
136
137impl std::cmp::PartialEq for Buffer {
138    fn eq(&self, other: &Self) -> bool {
139        if self.buf_len != self.buf_len {
140            return false;
141        }
142
143        self.as_slice().eq(other.as_slice())
144    }
145}
146
147impl std::cmp::Eq for Buffer {}
148
149impl std::hash::Hash for Buffer {
150    fn hash<H: Hasher>(&self, state: &mut H) {
151        self.as_slice().hash(state)
152    }
153}
154
155pub struct BufferReader<'a, 'b> {
156    raw_buffer: &'a mut Buffer,
157    data_types: &'b [u8],
158}
159
160impl<'a, 'b> BufferReader<'a, 'b> {
161    fn new(raw_buffer: &'a mut Buffer, data_types: &'b [u8]) -> Self {
162        BufferReader {
163            data_types,
164            raw_buffer,
165        }
166    }
167
168    #[inline]
169    fn index_out_of_bounds_check(
170        &self,
171        index: usize,
172        field_len: usize,
173        data_type: u8,
174    ) -> Result<(), std::io::Error> {
175        if self.raw_buffer.field_pos_index[index] + field_len > self.raw_buffer.buf_len {
176            return Err(std::io::Error::from(ErrorKind::UnexpectedEof));
177        }
178
179        if self.data_types[index] != data_type {
180            return Err(std::io::Error::from(ErrorKind::InvalidData));
181        }
182
183        Ok(())
184    }
185
186    pub fn get_bool(&mut self, index: usize) -> Result<bool, std::io::Error> {
187        self.index_out_of_bounds_check(index, 1, types::BOOL)?;
188
189        let start = self.raw_buffer.field_pos_index[index];
190        let s = self
191            .raw_buffer
192            .buf
193            .get(start..start + 1)
194            .map(|x| x[0] == 1)
195            .unwrap();
196
197        Ok(s)
198    }
199
200    pub fn get_i8(&mut self, index: usize) -> Result<i8, std::io::Error> {
201        self.index_out_of_bounds_check(index, 1, types::I8)?;
202
203        let start = self.raw_buffer.field_pos_index[index];
204        let s = self
205            .raw_buffer
206            .buf
207            .get(start..start + 1)
208            .map(|x| x[0] as i8)
209            .unwrap();
210
211        Ok(s)
212    }
213
214    pub fn get_u8(&mut self, index: usize) -> Result<u8, std::io::Error> {
215        self.index_out_of_bounds_check(index, 1, types::U8)?;
216
217        let start = self.raw_buffer.field_pos_index[index];
218        let s = self
219            .raw_buffer
220            .buf
221            .get(start..start + 1)
222            .map(|x| x[0])
223            .unwrap();
224
225        Ok(s)
226    }
227
228    pub fn get_i16(&mut self, index: usize) -> Result<i16, std::io::Error> {
229        self.index_out_of_bounds_check(index, 2, types::I16)?;
230
231        let start = self.raw_buffer.field_pos_index[index];
232        let s = self
233            .raw_buffer
234            .buf
235            .get(start..start + 2)
236            .map(|x| unsafe { i16::from_le_bytes(*(x as *const _ as *const [_; 2])) })
237            .unwrap();
238
239        Ok(s)
240    }
241
242    pub fn get_u16(&mut self, index: usize) -> Result<u16, std::io::Error> {
243        self.index_out_of_bounds_check(index, 2, types::U16)?;
244
245        let start = self.raw_buffer.field_pos_index[index];
246        let s = self
247            .raw_buffer
248            .buf
249            .get(start..start + 2)
250            .map(|x| unsafe { u16::from_le_bytes(*(x as *const _ as *const [_; 2])) })
251            .unwrap();
252
253        Ok(s)
254    }
255
256    pub fn get_i32(&mut self, index: usize) -> Result<i32, std::io::Error> {
257        self.index_out_of_bounds_check(index, 4, types::I32)?;
258
259        let start = self.raw_buffer.field_pos_index[index];
260        let s = self
261            .raw_buffer
262            .buf
263            .get(start..start + 4)
264            .map(|x| unsafe { i32::from_le_bytes(*(x as *const _ as *const [_; 4])) })
265            .unwrap();
266
267        Ok(s)
268    }
269
270    pub fn get_u32(&mut self, index: usize) -> Result<u32, std::io::Error> {
271        self.index_out_of_bounds_check(index, 4, types::U32)?;
272
273        let start = self.raw_buffer.field_pos_index[index];
274        let s = self
275            .raw_buffer
276            .buf
277            .get(start..start + 4)
278            .map(|x| unsafe { u32::from_le_bytes(*(x as *const _ as *const [_; 4])) })
279            .unwrap();
280
281        Ok(s)
282    }
283
284    pub fn get_i64(&mut self, index: usize) -> Result<i64, std::io::Error> {
285        self.index_out_of_bounds_check(index, 8, types::I64)?;
286
287        let start = self.raw_buffer.field_pos_index[index];
288        let s = self
289            .raw_buffer
290            .buf
291            .get(start..start + 8)
292            .map(|x| unsafe { i64::from_le_bytes(*(x as *const _ as *const [_; 8])) })
293            .unwrap();
294
295        Ok(s)
296    }
297
298    pub fn get_u64(&mut self, index: usize) -> Result<u64, std::io::Error> {
299        self.index_out_of_bounds_check(index, 8, types::U64)?;
300
301        let start = self.raw_buffer.field_pos_index[index];
302        let s = self
303            .raw_buffer
304            .buf
305            .get(start..start + 8)
306            .map(|x| unsafe { u64::from_le_bytes(*(x as *const _ as *const [_; 8])) })
307            .unwrap();
308
309        Ok(s)
310    }
311
312    pub fn get_f32(&mut self, index: usize) -> Result<f32, std::io::Error> {
313        self.index_out_of_bounds_check(index, 4, types::F32)?;
314
315        let start = self.raw_buffer.field_pos_index[index];
316        let s = self
317            .raw_buffer
318            .buf
319            .get(start..start + 4)
320            .map(|x| unsafe { f32::from_le_bytes(*(x as *const _ as *const [_; 4])) })
321            .unwrap();
322
323        Ok(s)
324    }
325
326    pub fn get_f64(&mut self, index: usize) -> Result<f64, std::io::Error> {
327        self.index_out_of_bounds_check(index, 8, types::F64)?;
328
329        let start = self.raw_buffer.field_pos_index[index];
330        let s = self
331            .raw_buffer
332            .buf
333            .get(start..start + 8)
334            .map(|x| unsafe { f64::from_le_bytes(*(x as *const _ as *const [_; 8])) })
335            .unwrap();
336
337        Ok(s)
338    }
339
340    pub fn get_str(&mut self, index: usize) -> Result<String, std::io::Error> {
341        match self.get_bytes(index) {
342            Ok(bytes) => String::from_utf8(bytes.to_vec())
343                .map_err(|_e| std::io::Error::from(ErrorKind::InvalidData)),
344            Err(e) => Err(e),
345        }
346    }
347
348    pub fn get_bytes(&mut self, index: usize) -> Result<&[u8], std::io::Error> {
349        let start = self.raw_buffer.field_pos_index[index];
350        let s = self
351            .raw_buffer
352            .buf
353            .get(start..start + 4)
354            .map(|x| unsafe { u32::from_le_bytes(*(x as *const _ as *const [_; 4])) })
355            .unwrap();
356
357        let len = s as usize;
358
359        self.index_out_of_bounds_check(index, len + 4, types::BYTES)?;
360
361        let start = start + 4;
362
363        let s = self.raw_buffer.buf.get(start..start + len).unwrap();
364        Ok(s)
365    }
366
367    pub fn get_bytes_mut(&mut self, index: usize) -> Result<&mut [u8], std::io::Error> {
368        let start = self.raw_buffer.field_pos_index[index];
369        let s = self
370            .raw_buffer
371            .buf
372            .get(start..start + 4)
373            .map(|x| unsafe { u32::from_le_bytes(*(x as *const _ as *const [_; 4])) })
374            .unwrap();
375
376        let len = s as usize;
377
378        self.index_out_of_bounds_check(index, len + 4, types::BYTES)?;
379
380        let start = start + 4;
381
382        let s = self.raw_buffer.buf.get_mut(start..start + len).unwrap();
383        Ok(s)
384    }
385
386    pub fn get_bytes_raw(&mut self, index: usize) -> Result<&[u8], std::io::Error> {
387        let data_type = self.data_types[index];
388        if data_type == types::BYTES {
389            self.get_bytes(index)
390        } else {
391            let len = types::len(data_type) as usize;
392            let start = self.raw_buffer.field_pos_index[index];
393
394            let s = self.raw_buffer.buf.get(start..start + len).unwrap();
395
396            Ok(s)
397        }
398    }
399
400    pub fn get_bytes_raw_mut(&mut self, index: usize) -> Result<&mut [u8], std::io::Error> {
401        let data_type = self.data_types[index];
402        if data_type == types::BYTES {
403            self.get_bytes_mut(index)
404        } else {
405            let len = types::len(data_type) as usize;
406            let start = self.raw_buffer.field_pos_index[index];
407
408            let s = self.raw_buffer.buf.get_mut(start..start + len).unwrap();
409
410            Ok(s)
411        }
412    }
413}
414
415pub struct BufferWriter<'a, 'b> {
416    raw_buffer: &'a mut Buffer,
417    data_types: &'b [u8],
418    write_field_step: usize,
419    // write_position: usize,
420}
421
422impl<'a, 'b> BufferWriter<'a, 'b> {
423    fn new(raw_buffer: &'a mut Buffer, data_types: &'b [u8]) -> Self {
424        BufferWriter {
425            raw_buffer,
426            data_types,
427            write_field_step: 0,
428        }
429    }
430
431    #[inline]
432    fn data_type_check(&mut self, data_type: u8) -> Result<(), std::io::Error> {
433        if self.data_types[self.write_field_step] != data_type {
434            return Err(std::io::Error::from(ErrorKind::InvalidInput));
435        }
436
437        self.write_field_step += 1;
438        Ok(())
439    }
440
441    #[inline]
442    fn step_position(&mut self, pos_step_len: usize) {
443        self.raw_buffer
444            .field_pos_index
445            .push(self.raw_buffer.buf_len);
446        self.raw_buffer.buf_len += pos_step_len;
447    }
448
449    pub fn set_bool(&mut self, value: bool) -> Result<(), std::io::Error> {
450        self.data_type_check(types::BOOL)?;
451
452        let value = if value { 1 } else { 0 };
453
454        self.step_position(1);
455
456        self.raw_buffer.buf.put_u8(value);
457        Ok(())
458    }
459
460    pub fn set_i8(&mut self, value: i8) -> Result<(), std::io::Error> {
461        self.data_type_check(types::I8)?;
462
463        self.step_position(1);
464
465        self.raw_buffer.buf.put_i8(value);
466        Ok(())
467    }
468
469    pub fn set_u8(&mut self, value: u8) -> Result<(), std::io::Error> {
470        self.data_type_check(types::U8)?;
471
472        self.step_position(1);
473
474        self.raw_buffer.buf.put_u8(value);
475        Ok(())
476    }
477
478    pub fn set_i16(&mut self, value: i16) -> Result<(), std::io::Error> {
479        self.data_type_check(types::I16)?;
480
481        self.step_position(2);
482
483        self.raw_buffer.buf.put_i16_le(value);
484        Ok(())
485    }
486
487    pub fn set_u16(&mut self, value: u16) -> Result<(), std::io::Error> {
488        self.data_type_check(types::U16)?;
489
490        self.step_position(2);
491
492        self.raw_buffer.buf.put_u16_le(value);
493        Ok(())
494    }
495
496    pub fn set_i32(&mut self, value: i32) -> Result<(), std::io::Error> {
497        self.data_type_check(types::I32)?;
498
499        self.step_position(4);
500
501        self.raw_buffer.buf.put_i32_le(value);
502        Ok(())
503    }
504
505    pub fn set_u32(&mut self, value: u32) -> Result<(), std::io::Error> {
506        self.data_type_check(types::U32)?;
507
508        self.step_position(4);
509
510        self.raw_buffer.buf.put_u32_le(value);
511        Ok(())
512    }
513
514    pub fn set_i64(&mut self, value: i64) -> Result<(), std::io::Error> {
515        self.data_type_check(types::I64)?;
516
517        self.step_position(8);
518
519        self.raw_buffer.buf.put_i64_le(value);
520        Ok(())
521    }
522
523    pub fn set_u64(&mut self, value: u64) -> Result<(), std::io::Error> {
524        self.data_type_check(types::U64)?;
525
526        self.step_position(8);
527
528        self.raw_buffer.buf.put_u64_le(value);
529        Ok(())
530    }
531
532    pub fn set_f32(&mut self, value: f32) -> Result<(), std::io::Error> {
533        self.data_type_check(types::F32)?;
534
535        self.step_position(4);
536
537        self.raw_buffer.buf.put_f32_le(value);
538        Ok(())
539    }
540
541    pub fn set_f64(&mut self, value: f64) -> Result<(), std::io::Error> {
542        self.data_type_check(types::F64)?;
543
544        self.step_position(8);
545
546        self.raw_buffer.buf.put_f64_le(value);
547        Ok(())
548    }
549
550    pub fn set_str(&mut self, value: &str) -> Result<(), std::io::Error> {
551        let s = value.as_bytes();
552        self.set_bytes(s)
553    }
554
555    pub fn set_bytes(&mut self, value: &[u8]) -> Result<(), std::io::Error> {
556        self.data_type_check(types::BYTES)?;
557
558        let len = value.len();
559        self.step_position(len + 4);
560
561        self.raw_buffer.buf.put_u32_le(len as u32);
562        self.raw_buffer.buf.put_slice(value);
563        Ok(())
564    }
565
566    pub fn set_bytes_raw(&mut self, value: &[u8]) -> Result<(), std::io::Error> {
567        let data_type = self.data_types[self.write_field_step];
568        if data_type == types::BYTES {
569            self.set_bytes(value)
570        } else {
571            let len = types::len(data_type) as usize;
572            if len != value.len() {
573                return Err(std::io::Error::from(ErrorKind::InvalidInput));
574            }
575
576            self.write_field_step += 1;
577
578            self.step_position(len);
579
580            self.raw_buffer.buf.put_slice(value);
581            Ok(())
582        }
583    }
584}
585
586#[cfg(test)]
587mod tests {
588    use crate::{types, Buffer};
589    use bytes::Buf;
590
591    #[test]
592    pub fn buffer_test() {
593        let mut buffer = Buffer::new();
594        let data_types = vec![
595            types::BOOL,
596            types::I8,
597            types::U8,
598            types::I16,
599            types::U16,
600            types::I32,
601            types::U32,
602            types::I64,
603            types::U64,
604            types::F32,
605            types::F64,
606            types::BYTES,
607            types::BYTES,
608            types::BYTES,
609            types::I32,
610        ];
611
612        let strs = vec![
613            "aaaa-bbbb-cccc-dddd",
614            "cccc-bbbb-aaaa",
615            "aaaa-bbbb-cccc-dddd-eeee",
616            "dddd-cccc-bbbb-aaaa",
617            "bbbb",
618        ];
619        for i in 0..strs.len() {
620            let uuid1 = strs[i];
621            let uuid2 = uuid::Uuid::new_v4().to_string();
622            let uuid2 = uuid2.as_str();
623
624            let mut writer = buffer.as_writer(&data_types);
625
626            writer.set_bool(i % 2 == 0).unwrap();
627
628            writer.set_i8((10 + i) as i8).unwrap();
629            writer.set_u8((11 + i) as u8).unwrap();
630
631            writer.set_i16((12 + i) as i16).unwrap();
632            writer.set_u16((13 + i) as u16).unwrap();
633
634            writer.set_i32((14 + i) as i32).unwrap();
635            writer.set_u32((15 + i) as u32).unwrap();
636
637            writer.set_i64((16 + i) as i64).unwrap();
638            writer.set_u64((17 + i) as u64).unwrap();
639
640            writer.set_f32(18.001 + i as f32).unwrap();
641            writer.set_f64(19.002 + i as f64).unwrap();
642
643            writer.set_str(uuid1).unwrap();
644            writer.set_str(uuid2).unwrap();
645            writer.set_str("").unwrap();
646
647            writer.set_i32((5 + i) as i32).unwrap();
648
649            println!("{:?}", buffer.buf.bytes());
650
651            let mut reader = buffer.as_reader(&data_types);
652
653            assert_eq!(reader.get_bool(0).unwrap(), i % 2 == 0);
654
655            assert_eq!(reader.get_i8(1).unwrap(), (10 + i) as i8);
656            assert_eq!(reader.get_u8(2).unwrap(), (11 + i) as u8);
657
658            assert_eq!(reader.get_i16(3).unwrap(), (12 + i) as i16);
659            assert_eq!(reader.get_u16(4).unwrap(), (13 + i) as u16);
660
661            assert_eq!(reader.get_i32(5).unwrap(), (14 + i) as i32);
662            assert_eq!(reader.get_u32(6).unwrap(), (15 + i) as u32);
663
664            assert_eq!(reader.get_i64(7).unwrap(), (16 + i) as i64);
665            assert_eq!(reader.get_u64(8).unwrap(), (17 + i) as u64);
666
667            assert_eq!(reader.get_f32(9).unwrap(), 18.001 + i as f32);
668            assert_eq!(reader.get_f64(10).unwrap(), 19.002 + i as f64);
669
670            assert_eq!(reader.get_str(11).unwrap(), uuid1.to_string());
671            assert_eq!(reader.get_str(12).unwrap(), uuid2.to_string());
672            assert_eq!(reader.get_str(13).unwrap(), "".to_string());
673
674            assert_eq!(reader.get_i32(14).unwrap(), (5 + i) as i32);
675
676            // buffer.reset();
677        }
678    }
679
680    #[test]
681    pub fn buf_extend_test() {
682        let mut buffer0 = Buffer::new();
683        let mut buffer1 = Buffer::new();
684
685        let data_types0 = [
686            types::I8,
687            types::I16,
688            types::I32,
689            types::I64,
690            types::F32,
691            types::BYTES,
692            types::I32,
693        ];
694        let data_types1 = [
695            types::U8,
696            types::U16,
697            types::U32,
698            types::U64,
699            types::F64,
700            types::BYTES,
701            types::U32,
702        ];
703
704        let uuid1 = "b871544b-c044-495c-98ee-f5aa34660527".to_string();
705        let uuid2 = "6af8fda0-e9fa-498b-829a-bb3c7b87554b".to_string();
706
707        {
708            let mut writer = buffer0.as_writer(&data_types0);
709
710            writer.set_i8((10) as i8).unwrap();
711            writer.set_i16((12) as i16).unwrap();
712            writer.set_i32((14) as i32).unwrap();
713            writer.set_i64((16) as i64).unwrap();
714            writer.set_f32(18.001 as f32).unwrap();
715            writer.set_str(uuid1.as_str()).unwrap();
716            writer.set_i32((5) as i32).unwrap();
717        }
718
719        {
720            let mut writer = buffer1.as_writer(&data_types1);
721
722            writer.set_u8((11) as u8).unwrap();
723            writer.set_u16((13) as u16).unwrap();
724            writer.set_u32((15) as u32).unwrap();
725            writer.set_u64((17) as u64).unwrap();
726            writer.set_f64(19.002 as f64).unwrap();
727            writer.set_str(uuid2.as_str()).unwrap();
728            writer.set_u32((5) as u32).unwrap();
729        }
730
731        println!("{:?}", buffer0.buf.bytes());
732        println!("{:?}", buffer1.buf.bytes());
733
734        buffer0.extend(&buffer1).unwrap();
735        println!("{:?}", buffer0.buf.bytes());
736
737        let mut data_type_merge = data_types0.to_vec();
738        data_type_merge.extend_from_slice(&data_types1);
739        let mut reader = buffer0.as_reader(data_type_merge.as_slice());
740
741        assert_eq!(reader.get_i8(0).unwrap(), (10) as i8);
742        assert_eq!(reader.get_i16(1).unwrap(), (12) as i16);
743        assert_eq!(reader.get_i32(2).unwrap(), (14) as i32);
744        assert_eq!(reader.get_i64(3).unwrap(), (16) as i64);
745        assert_eq!(reader.get_f32(4).unwrap(), 18.001 as f32);
746        assert_eq!(reader.get_str(5).unwrap(), uuid1);
747        assert_eq!(reader.get_i32(6).unwrap(), (5) as i32);
748
749        assert_eq!(reader.get_u8(7).unwrap(), (11) as u8);
750        assert_eq!(reader.get_u16(8).unwrap(), (13) as u16);
751        assert_eq!(reader.get_u32(9).unwrap(), (15) as u32);
752        assert_eq!(reader.get_u64(10).unwrap(), (17) as u64);
753        assert_eq!(reader.get_f64(11).unwrap(), 19.002 as f64);
754        assert_eq!(reader.get_str(12).unwrap(), uuid2);
755        assert_eq!(reader.get_u32(13).unwrap(), (5) as u32);
756    }
757}
rlink_buffer/buffer.rs

rlink_buffer/
buffer.rs
