bin_buffer/
lib.rs

1#![warn(missing_docs)]
2#![warn(missing_doc_code_examples)]
3
4//! This is a simple crate to read and write binairy data.
5//! # Example:
6//! ```
7//! use bin_buffer::*;
8//! let x = 16u16;
9//! let y = String::from("hello");
10//! let z = (0.0001f64,1.1111f64);
11//! let mut buffer = Vec::new();
12//! x.into_buffer(&mut buffer);
13//! y.copy_into_buffer(&mut buffer);
14//! z.into_buffer(&mut buffer);
15//! let mut buffer = ReadBuffer::from_raw(buffer);
16//! assert_eq!(Some(x), u16::from_buffer(&mut buffer));
17//! assert_eq!(Some(y), String::from_buffer(&mut buffer));
18//! assert_eq!(Some(z), <(f64,f64)>::from_buffer(&mut buffer));
19//! ```
20use std::io::prelude::*;
21use std::fs::OpenOptions;
22
23/// Buffer: a Vector of bytes
24pub type Buffer = Vec<u8>;
25
26/// Buffer from which we can read.
27pub struct ReadBuffer{
28    buffer: Buffer,
29    iter: usize,
30}
31
32impl ReadBuffer{
33    /// Create ReadBuffer from Buffer.
34    pub fn from_raw(vec: Buffer) -> Self{
35        Self{
36            buffer: vec,
37            iter: 0,
38        }
39    }
40    /// Turn ReadBuffer into Buffer.
41    pub fn into_raw(self) -> Buffer{
42        self.buffer
43    }
44    /// If the ReadBuffer is empty.
45    pub fn is_empty(&self) -> bool{
46        self.buffer.is_empty()
47    }
48}
49
50/// Object can be read and written to a Buffer
51pub trait Bufferable where Self: std::marker::Sized{
52    /// Consume yourself and add to the end of the buffer
53    fn into_buffer(self, vec: &mut Buffer);
54    /// Copy yourself and add to the end of the buffer.
55    fn copy_into_buffer(&self, vec: &mut Buffer);
56    /// Read object from buffer
57    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>;
58}
59/// Implements Bufferable for u64.
60/// # Example
61/// ```
62/// use bin_buffer::*;
63/// let x = 81234u64;
64/// let mut buffer = Vec::new();
65/// x.into_buffer(&mut buffer);
66/// let mut buffer = ReadBuffer::from_raw(buffer);
67/// let y = u64::from_buffer(&mut buffer);
68/// ```
69impl Bufferable for u64{
70    fn into_buffer(self, vec: &mut Buffer){
71        vec.push(((self >> 56) & 0xff) as u8);
72        vec.push(((self >> 48) & 0xff) as u8);
73        vec.push(((self >> 40) & 0xff) as u8);
74        vec.push(((self >> 32) & 0xff) as u8);
75        vec.push(((self >> 24) & 0xff) as u8);
76        vec.push(((self >> 16) & 0xff) as u8);
77        vec.push(((self >> 8) & 0xff) as u8);
78        vec.push((self & 0xff) as u8);
79    }
80
81    fn copy_into_buffer(&self, vec: &mut Buffer){
82        self.clone().into_buffer(vec);
83    }
84
85    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
86        if buf.iter + 8 > buf.buffer.len() { return Option::None; }
87        let mut val: u64 = 0;
88        val += u64::from(buf.buffer[(buf.iter    )]) << 56;
89        val += u64::from(buf.buffer[(buf.iter + 1)]) << 48;
90        val += u64::from(buf.buffer[(buf.iter + 2)]) << 40;
91        val += u64::from(buf.buffer[(buf.iter + 3)]) << 32;
92        val += u64::from(buf.buffer[(buf.iter + 4)]) << 24;
93        val += u64::from(buf.buffer[(buf.iter + 5)]) << 16;
94        val += u64::from(buf.buffer[(buf.iter + 6)]) << 8;
95        val += u64::from(buf.buffer[(buf.iter + 7)]);
96        buf.iter += 8;
97        Option::Some(val)
98    }
99}
100/// Implements Bufferable for usize.
101/// Only for 64 bit.
102/// # Example
103/// ```
104/// use bin_buffer::*;
105/// let x = 81234usize;
106/// let mut buffer = Vec::new();
107/// x.into_buffer(&mut buffer);
108/// let mut buffer = ReadBuffer::from_raw(buffer);
109/// let y = usize::from_buffer(&mut buffer);
110/// ```
111impl Bufferable for usize{
112    fn into_buffer(self, vec: &mut Buffer){
113        vec.push(((self >> 56) & 0xff) as u8);
114        vec.push(((self >> 48) & 0xff) as u8);
115        vec.push(((self >> 40) & 0xff) as u8);
116        vec.push(((self >> 32) & 0xff) as u8);
117        vec.push(((self >> 24) & 0xff) as u8);
118        vec.push(((self >> 16) & 0xff) as u8);
119        vec.push(((self >> 8) & 0xff) as u8);
120        vec.push((self & 0xff) as u8);
121    }
122
123    fn copy_into_buffer(&self, vec: &mut Buffer){
124        self.clone().into_buffer(vec);
125    }
126
127    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
128        if buf.iter + 8 > buf.buffer.len() { return Option::None; }
129        let mut val: usize = 0;
130        val += usize::from(buf.buffer[(buf.iter    )]) << 56;
131        val += usize::from(buf.buffer[(buf.iter + 1)]) << 48;
132        val += usize::from(buf.buffer[(buf.iter + 2)]) << 40;
133        val += usize::from(buf.buffer[(buf.iter + 3)]) << 32;
134        val += usize::from(buf.buffer[(buf.iter + 4)]) << 24;
135        val += usize::from(buf.buffer[(buf.iter + 5)]) << 16;
136        val += usize::from(buf.buffer[(buf.iter + 6)]) << 8;
137        val += usize::from(buf.buffer[(buf.iter + 7)]);
138        buf.iter += 8;
139        Option::Some(val)
140    }
141}
142/// Implements Bufferable for u32.
143/// # Example
144/// ```
145/// use bin_buffer::*;
146/// let x = 71u32;
147/// let mut buffer = Vec::new();
148/// x.into_buffer(&mut buffer);
149/// let mut buffer = ReadBuffer::from_raw(buffer);
150/// let y = u32::from_buffer(&mut buffer);
151/// ```
152impl Bufferable for u32{
153    fn into_buffer(self, vec: &mut Buffer){
154        vec.push(((self >> 24) & 0xff) as u8);
155        vec.push(((self >> 16) & 0xff) as u8);
156        vec.push(((self >> 8) & 0xff) as u8);
157        vec.push((self & 0xff) as u8);
158    }
159
160    fn copy_into_buffer(&self, vec: &mut Buffer){
161        self.clone().into_buffer(vec);
162    }
163
164    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
165        if buf.iter + 4 > buf.buffer.len() { return Option::None; }
166        let mut val: u32 = 0;
167        val += u32::from(buf.buffer[(buf.iter    )]) << 24;
168        val += u32::from(buf.buffer[(buf.iter + 1)]) << 16;
169        val += u32::from(buf.buffer[(buf.iter + 2)]) << 8;
170        val += u32::from(buf.buffer[(buf.iter + 3)]);
171        buf.iter += 4;
172        Option::Some(val)
173    }
174}
175/// Implements Bufferable for u16.
176/// # Example
177/// ```
178/// use bin_buffer::*;
179/// let x = 31u16;
180/// let mut buffer = Vec::new();
181/// x.into_buffer(&mut buffer);
182/// let mut buffer = ReadBuffer::from_raw(buffer);
183/// let y = u16::from_buffer(&mut buffer);
184/// ```
185impl Bufferable for u16{
186    fn into_buffer(self, vec: &mut Buffer){
187        vec.push(((self >> 8) & 0xff) as u8);
188        vec.push((self & 0xff) as u8);
189    }
190
191    fn copy_into_buffer(&self, vec: &mut Buffer){
192        self.clone().into_buffer(vec);
193    }
194
195    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
196        if buf.iter + 2 > buf.buffer.len() { return Option::None; }
197        let mut val: u16 = 0;
198        val += u16::from(buf.buffer[(buf.iter    )]) << 8;
199        val += u16::from(buf.buffer[(buf.iter + 1)]);
200        buf.iter += 2;
201        Option::Some(val)
202    }
203}
204/// Implements Bufferable for u8.
205/// # Example
206/// ```
207/// use bin_buffer::*;
208/// let x = 1u8;
209/// let mut buffer = Vec::new();
210/// x.into_buffer(&mut buffer);
211/// let mut buffer = ReadBuffer::from_raw(buffer);
212/// let y = u8::from_buffer(&mut buffer);
213/// ```
214impl Bufferable for u8{
215    fn into_buffer(self, vec: &mut Buffer){
216        vec.push(self);
217    }
218
219    fn copy_into_buffer(&self, vec: &mut Buffer){
220        self.clone().into_buffer(vec);
221    }
222
223    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
224        if buf.iter + 1 > buf.buffer.len() { return Option::None; }
225        let val = buf.buffer[buf.iter];
226        buf.iter += 1;
227        Option::Some(val)
228    }
229}
230/// Implements Bufferable for f64.
231/// # Example
232/// ```
233/// use bin_buffer::*;
234/// let x = 1.001f64;
235/// let mut buffer = Vec::new();
236/// x.into_buffer(&mut buffer);
237/// let mut buffer = ReadBuffer::from_raw(buffer);
238/// let y = f64::from_buffer(&mut buffer);
239/// ```
240impl Bufferable for f64{
241    fn into_buffer(self, vec: &mut Buffer){
242        let bytes = self.to_be_bytes();
243        for b in bytes.iter(){
244            vec.push(*b);
245        }
246    }
247
248    fn copy_into_buffer(&self, vec: &mut Buffer){
249        self.clone().into_buffer(vec);
250    }
251
252    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
253        if buf.iter + 8 > buf.buffer.len() { return Option::None; }
254        let mut bytes = [0u8; 8];
255        for (i, byte) in bytes.iter_mut().enumerate(){
256            *byte = buf.buffer[buf.iter + i];
257        }
258        buf.iter += 8;
259        Option::Some(f64::from_be_bytes(bytes))
260    }
261}
262/// Implements Bufferable for f32.
263/// # Example
264/// ```
265/// use bin_buffer::*;
266/// let x = 1.001f32;
267/// let mut buffer = Vec::new();
268/// x.into_buffer(&mut buffer);
269/// let mut buffer = ReadBuffer::from_raw(buffer);
270/// let y = f32::from_buffer(&mut buffer);
271/// ```
272impl Bufferable for f32{
273    fn into_buffer(self, vec: &mut Buffer){
274        let bytes = self.to_be_bytes();
275        for b in bytes.iter(){
276            vec.push(*b);
277        }
278    }
279
280    fn copy_into_buffer(&self, vec: &mut Buffer){
281        self.clone().into_buffer(vec);
282    }
283
284    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
285        if buf.iter + 4 > buf.buffer.len() { return Option::None; }
286        let mut bytes = [0u8; 4];
287        for (i,byte) in bytes.iter_mut().enumerate(){
288            *byte = buf.buffer[buf.iter + i];
289        }
290        buf.iter += 4;
291        Option::Some(f32::from_be_bytes(bytes))
292    }
293}
294/// Implements Bufferable for String.
295/// # Example
296/// ```
297/// use bin_buffer::*;
298/// let x = String::from("cool and good");
299/// let mut buffer = Vec::new();
300/// x.copy_into_buffer(&mut buffer);
301/// let mut buffer = ReadBuffer::from_raw(buffer);
302/// let y = String::from_buffer(&mut buffer);
303/// ```
304impl Bufferable for String{
305    fn into_buffer(self, vec: &mut Buffer){
306        self.copy_into_buffer(vec);
307    }
308
309    fn copy_into_buffer(&self, vec: &mut Buffer){
310        let bytes = self.as_bytes();
311        let len = bytes.len();
312        (len as u64).into_buffer(vec);
313        for b in bytes.iter(){
314            vec.push(*b);
315        }
316    }
317
318    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
319        let len = (u64::from_buffer(buf))? as usize;
320        if buf.iter + len > buf.buffer.len() { return Option::None; }
321        let mut bytes = Vec::new();
322        for i in 0..len{
323            bytes.push(buf.buffer[buf.iter + i]);
324        }
325        buf.iter += len;
326        if let Ok(r) = String::from_utf8(bytes) { Some(r) }
327        else { Option::None }
328    }
329}
330/// Just copies the content of the second buffer to the end of the first buffer.
331/// # Example
332/// ```
333/// use bin_buffer::*;
334/// let mut buffer = vec![0,1,2,3];
335/// let source = &vec![4,5];
336/// buffer_append_buffer(&mut buffer, source);
337/// assert_eq!(buffer,vec![0,1,2,3,4,5]);
338/// ```
339pub fn buffer_append_buffer(vec: &mut Buffer, string: &[u8]){
340    for byte in string{
341        vec.push(*byte);
342    }
343}
344/// Writes a buffer to a file.
345/// Will create a new file if none exists or overwrite otherwise.
346/// # Example
347/// ```
348/// use bin_buffer::*;
349/// let buf = vec![0,1,2];
350/// let path = std::path::Path::new("./buffer0.ntbr");
351/// buffer_write_file(&path, &buf);
352/// let res = buffer_read_file(&path);
353/// assert_eq!(res, Option::Some(buf));
354/// ```
355pub fn buffer_write_file(path: &std::path::Path, vec: &[u8]) -> bool{
356    let file = if let Ok(f) =
357        OpenOptions::new().write(true).create(true).truncate(true).open(path) { f }
358    else { return false; };
359    let mut opened = file;
360    if opened.write_all(&vec).is_err() {return false;}
361    true
362}
363/// Writes a buffer to the end of a file.
364/// Will create a new file if none exists.
365/// # Example
366/// ```
367/// use bin_buffer::*;
368/// let a = vec![0,1,2];
369/// let path = std::path::Path::new("./buffer1.ntbr");
370/// buffer_write_file(&path, &a);
371/// let b = vec![3,4];
372/// buffer_write_file_append(&path, &b);
373/// let res = buffer_read_file(&path);
374/// assert_eq!(res, Option::Some(vec![0,1,2,3,4]));
375/// ```
376pub fn buffer_write_file_append(path: &std::path::Path, vec: &[u8]) -> bool{
377    let file = if let Ok(f) =
378        OpenOptions::new().write(true).create(true).append(true).open(path) { f }
379    else { return false; };
380    let mut opened = file;
381    if opened.write_all(&vec).is_err() {return false;}
382    true
383}
384/// Reads a buffer from a file.
385/// # Example
386/// ```
387/// use bin_buffer::*;
388/// let path = std::path::Path::new("./buffer2.ntbr");
389/// let buffer = vec![0,1,2,3];
390/// buffer_write_file(&path, &buffer);
391/// let read_result = buffer_read_file(&path);
392/// assert_eq!(read_result, Option::Some(buffer));
393/// ```
394pub fn buffer_read_file(path: &std::path::Path) -> Option<Buffer>{
395    let file = if let Ok(f) =
396        OpenOptions::new().read(true).open(path) { f }
397    else { return Option::None; };
398    let mut opened = file;
399    let mut vec: Buffer = Vec::new();
400    if opened.read_to_end(&mut vec).is_err() { return Option::None; }
401    Option::Some(vec)
402}
403/// Implements Bufferable for Vec<Bufferable + Clone>
404/// # Example
405/// ```
406/// use bin_buffer::*;
407/// let x = vec![0.0f32,1.0,2.0,3.0,4.0,5.5];
408/// let mut buffer = Vec::new();
409/// x.copy_into_buffer(&mut buffer);
410/// let mut buffer = ReadBuffer::from_raw(buffer);
411/// let y = Vec::<f32>::from_buffer(&mut buffer);
412/// ```
413impl<T: Bufferable + Clone> Bufferable for Vec<T>{
414    fn into_buffer(self, buf: &mut Buffer){
415        let len = self.len() as u64;
416        len.into_buffer(buf);
417        for x in self{
418            x.into_buffer(buf);
419        }
420    }
421
422    fn copy_into_buffer(&self, buf: &mut Buffer){
423        self.clone().into_buffer(buf);
424    }
425
426    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
427        let len = (u64::from_buffer(buf))?;
428        let mut vec = Vec::new();
429        for _ in 0..len{
430            let x = (T::from_buffer(buf))?;
431            vec.push(x);
432        }
433        Option::Some(vec)
434    }
435}
436/// Implements Bufferable for tuples where all U,V are Bufferable and Clone.
437/// # Example
438/// ```
439/// use bin_buffer::*;
440/// let x = (0.0f64,-12345.4321f64);
441/// let mut buffer = Vec::new();
442/// x.into_buffer(&mut buffer);
443/// let mut buffer = ReadBuffer::from_raw(buffer);
444/// let y =  <(f64,f64)>::from_buffer(&mut buffer);
445/// ```
446impl<U: Bufferable + Clone, V: Bufferable + Clone> Bufferable for (U,V){
447    fn into_buffer(self, buf: &mut Buffer){
448        self.0.into_buffer(buf);
449        self.1.into_buffer(buf);
450    }
451
452    fn copy_into_buffer(&self, buf: &mut Buffer){
453        self.clone().into_buffer(buf);
454    }
455
456    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
457        let x = (U::from_buffer(buf))?;
458        let y = (V::from_buffer(buf))?;
459        Option::Some((x,y))
460    }
461}
462/// Implements Bufferable for tuples (U,V,W) where all U,V,W are Bufferable and Clone.
463/// # Example
464/// ```
465/// use bin_buffer::*;
466/// let x = (0.0f64,-12345.4321f64,9999.0f64);
467/// let mut buffer = Vec::new();
468/// x.into_buffer(&mut buffer);
469/// let mut buffer = ReadBuffer::from_raw(buffer);
470/// let y= <(f64,f64,f64)>::from_buffer(&mut buffer);
471/// ```
472impl<U: Bufferable + Clone, V: Bufferable + Clone, W: Bufferable + Clone>
473    Bufferable for (U,V,W){
474    fn into_buffer(self, buf: &mut Buffer){
475        self.0.into_buffer(buf);
476        self.1.into_buffer(buf);
477        self.2.into_buffer(buf);
478    }
479
480    fn copy_into_buffer(&self, buf: &mut Buffer){
481        self.clone().into_buffer(buf);
482    }
483
484    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
485        let x = (U::from_buffer(buf))?;
486        let y = (V::from_buffer(buf))?;
487        let z = (W::from_buffer(buf))?;
488        Option::Some((x,y,z))
489    }
490}
491/// Implements Bufferable for tuples (U,V,W,X) where all U,V,W,X are Bufferable and Clone.
492/// # Example
493/// ```
494/// use bin_buffer::*;
495/// let x = (0.064,-12345.4321,9999.0,-999.0);
496/// let mut buffer = Vec::new();
497/// x.into_buffer(&mut buffer);
498/// let mut buffer = ReadBuffer::from_raw(buffer);
499/// let y= <(f64,f64,f64,f64)>::from_buffer(&mut buffer);
500/// ```
501impl<U: Bufferable + Clone, V: Bufferable + Clone, W: Bufferable + Clone, X: Bufferable + Clone>
502    Bufferable for (U,V,W,X){
503    fn into_buffer(self, buf: &mut Buffer){
504        self.0.into_buffer(buf);
505        self.1.into_buffer(buf);
506        self.2.into_buffer(buf);
507        self.3.into_buffer(buf);
508    }
509
510    fn copy_into_buffer(&self, buf: &mut Buffer){
511        self.clone().into_buffer(buf);
512    }
513
514    fn from_buffer(buf: &mut ReadBuffer) -> Option<Self>{
515        let x = (U::from_buffer(buf))?;
516        let y = (V::from_buffer(buf))?;
517        let z = (W::from_buffer(buf))?;
518        let w = (X::from_buffer(buf))?;
519        Option::Some((x,y,z,w))
520    }
521}
522
523#[cfg(test)]
524mod tests{
525    use crate::*;
526    #[test]
527    fn test_true(){
528        assert_eq!(true, true);
529    }
530    #[test]
531    fn test_u64(){
532        let x = 81234u64;
533        let mut buffer = Vec::new();
534        x.into_buffer(&mut buffer);
535        let mut buffer = ReadBuffer::from_raw(buffer);
536        assert_eq!(x, u64::from_buffer(&mut buffer).unwrap());
537        assert_eq!(Option::None, u64::from_buffer(&mut buffer));
538    }
539    #[test]
540    fn test_u32(){
541        let x = 71u32;
542        let mut buffer = Vec::new();
543        x.into_buffer(&mut buffer);
544        let mut buffer = ReadBuffer::from_raw(buffer);
545        assert_eq!(x, u32::from_buffer(&mut buffer).unwrap());
546        assert_eq!(Option::None, u16::from_buffer(&mut buffer));
547    }
548    #[test]
549    fn test_u16(){
550        let x = 31u16;
551        let y = 21u16;
552        let mut buffer = Vec::new();
553        x.into_buffer(&mut buffer);
554        y.into_buffer(&mut buffer);
555        let mut buffer = ReadBuffer::from_raw(buffer);
556        assert_eq!(x, u16::from_buffer(&mut buffer).unwrap());
557        assert_eq!(y, u16::from_buffer(&mut buffer).unwrap());
558        assert_eq!(Option::None, u16::from_buffer(&mut buffer));
559    }
560    #[test]
561    fn test_u8(){
562        let x = 1u8;
563        let y = 0u8;
564        let mut buffer = Vec::new();
565        x.into_buffer(&mut buffer);
566        y.into_buffer(&mut buffer);
567        let mut buffer = ReadBuffer::from_raw(buffer);
568        assert_eq!(x, u8::from_buffer(&mut buffer).unwrap());
569        assert_eq!(y, u8::from_buffer(&mut buffer).unwrap());
570        assert_eq!(Option::None, u8::from_buffer(&mut buffer));
571    }
572    #[test]
573    fn test_f64(){
574        let x = 1.001f64;
575        let y = 1.23456789;
576        let mut buffer = Vec::new();
577        x.into_buffer(&mut buffer);
578        y.into_buffer(&mut buffer);
579        let mut buffer = ReadBuffer::from_raw(buffer);
580        assert_eq!(x, f64::from_buffer(&mut buffer).unwrap());
581        assert_eq!(y, f64::from_buffer(&mut buffer).unwrap());
582        assert_eq!(Option::None, f64::from_buffer(&mut buffer));
583    }
584    #[test]
585    fn test_f32(){
586        let x = 1.001f32;
587        let y = 1.23456;
588        let mut buffer = Vec::new();
589        x.into_buffer(&mut buffer);
590        y.into_buffer(&mut buffer);
591        let mut buffer = ReadBuffer::from_raw(buffer);
592        assert_eq!(x, f32::from_buffer(&mut buffer).unwrap());
593        assert_eq!(y, f32::from_buffer(&mut buffer).unwrap());
594        assert_eq!(Option::None, f32::from_buffer(&mut buffer));
595    }
596    #[test]
597    fn test_string(){
598        let x = String::from("haha yes cool and good");
599        let y = 16u16;
600        let z = String::from("another one");
601        let mut buffer = Vec::new();
602        x.copy_into_buffer(&mut buffer);
603        y.into_buffer(&mut buffer);
604        z.copy_into_buffer(&mut buffer);
605        let mut buffer = ReadBuffer::from_raw(buffer);
606        assert_eq!(x, String::from_buffer(&mut buffer).unwrap());
607        assert_eq!(y, u16::from_buffer(&mut buffer).unwrap());
608        assert_eq!(z, String::from_buffer(&mut buffer).unwrap());
609        assert_eq!(Option::None, String::from_buffer(&mut buffer));
610    }
611    #[test]
612    fn test_f64_tuple(){
613        let x = (0.0f64,-12345.4321f64);
614        let mut buffer = Vec::new();
615        x.into_buffer(&mut buffer);
616        let mut buffer = ReadBuffer::from_raw(buffer);
617        assert_eq!(x, <(f64,f64)>::from_buffer(&mut buffer).unwrap());
618    }
619    #[test]
620    fn test_f64_triple(){
621        let x = (0.0f64,-12345.4321f64,9999.0f64);
622        let mut buffer = Vec::new();
623        x.into_buffer(&mut buffer);
624        let mut buffer = ReadBuffer::from_raw(buffer);
625        assert_eq!(Some(x), <(f64,f64,f64)>::from_buffer(&mut buffer));
626        assert_eq!(None, u8::from_buffer(&mut buffer));
627    }
628    #[test]
629    fn test_f64_quadruple(){
630        let x = (0.064,-12345.4321,9999.0,-999.0);
631        let mut buffer = Vec::new();
632        x.into_buffer(&mut buffer);
633        let mut buffer = ReadBuffer::from_raw(buffer);
634        assert_eq!(Some(x), <(f64,f64,f64,f64)>::from_buffer(&mut buffer));
635        assert_eq!(None, u8::from_buffer(&mut buffer));
636    }
637    #[test]
638    fn test_vec(){
639        let x = vec![0.0f32,1.0,2.0,3.0,4.0,5.5];
640        let mut buffer = Vec::new();
641        x.copy_into_buffer(&mut buffer);
642        let mut buffer = ReadBuffer::from_raw(buffer);
643        assert_eq!(Some(x), Vec::<f32>::from_buffer(&mut buffer));
644        assert_eq!(None, u8::from_buffer(&mut buffer));
645    }
646}
647
bin_buffer/lib.rs

bin_buffer/
lib.rs
