byte_array 0.1.3

A library that supports Java-like series processing with byteorder.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

/* ------------------------------------------------------------
    ByteArray
    Project.Github: "https://github.com/kerryeon/bytearray"
---------------------------------------------------------------
    Author:
        Name: "kerryeon"
        Email: "besqer996@gnu.ac.kr"
        Github: "https://github.com/kerryeon"
    Generated:
        Date: "3/8/2019"
------------------------------------------------------------ */

use byteorder::{
    BigEndian,
    ByteOrder,
};
use crate::{
    BinaryBuilder,
    ByteArray,
};
use std::mem::size_of;

macro_rules! generate {
($type: ident with default: $default: expr, toward: $toward: ident,
    endian: $endian: ident, read: $read: ident, write: $write: ident) => {

impl BinaryBuilder for $type {
    fn new() -> Self {
        $default
    }
    fn from_raw(ba: &mut ByteArray) -> Option<Self> {
        let now = ba.now();
        ba.seek_next(size_of::<Self>())?;
        Some($endian::$read(&ba.as_vec()[now..]) as $type)
    }
    fn to_raw(&self, ba: &mut ByteArray) {
        let len = ba.len();
        let vec = ba.as_vec();
        // Alloc
        for _ in 0..size_of::<Self>() {
            vec.push(0);
        }
        $endian::$write(&mut vec[len..], *self as $toward);
    }
}

};}

generate!(u16   with default: 0 , toward: u16,  endian: BigEndian, read: read_u16 , write: write_u16 );
generate!(u32   with default: 0 , toward: u32,  endian: BigEndian, read: read_u32 , write: write_u32 );
generate!(u64   with default: 0 , toward: u64,  endian: BigEndian, read: read_u64 , write: write_u64 );
generate!(u128  with default: 0 , toward: u128, endian: BigEndian, read: read_u128, write: write_u128);

generate!(i16   with default: 0 , toward: i16,  endian: BigEndian, read: read_i16 , write: write_i16 );
generate!(i32   with default: 0 , toward: i32,  endian: BigEndian, read: read_i32 , write: write_i32 );
generate!(i64   with default: 0 , toward: i64,  endian: BigEndian, read: read_i64 , write: write_i64 );
generate!(i128  with default: 0 , toward: i128, endian: BigEndian, read: read_i128, write: write_i128);

generate!(usize with default: 0 , toward: u64,  endian: BigEndian, read: read_u64 , write: write_u64 );
generate!(isize with default: 0 , toward: i64,  endian: BigEndian, read: read_i64 , write: write_i64 );

generate!(f32   with default: 0., toward: f32,  endian: BigEndian, read: read_f32 , write: write_f32 );
generate!(f64   with default: 0., toward: f64,  endian: BigEndian, read: read_f64 , write: write_f64 );