speedy 0.4.1

A fast binary serialization framework
Documentation 
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use std::io;
use std::mem;
use std::borrow::Cow;

use endianness::Endianness;
use readable::Readable;
use context::Context;

pub trait Reader< 'a, C: Context >: Sized {
    fn read_bytes( &mut self, output: &mut [u8] ) -> io::Result< () >;
    fn context( &self ) -> &C;
    fn context_mut( &mut self ) -> &mut C;

    #[inline]
    fn read_bytes_cow( &mut self, length: usize ) -> io::Result< Cow< 'a, [u8] > > {
        let mut buffer = Vec::with_capacity( length );
        unsafe { buffer.set_len( length ) };
        try!( self.read_bytes( &mut buffer ) );
        Ok( Cow::Owned( buffer ) )
    }

    #[inline]
    fn read_u8( &mut self ) -> io::Result< u8 > {
        let mut slice: [u8; 1] = unsafe { mem::uninitialized() };
        try!( self.read_bytes( &mut slice ) );
        Ok( slice[0] )
    }

    #[inline]
    fn read_i8( &mut self ) -> io::Result< i8 > {
        self.read_u8().map( |byte| byte as i8 )
    }

    #[inline]
    fn read_u16( &mut self ) -> io::Result< u16 > {
        let mut slice: [u8; 2] = unsafe { mem::uninitialized() };
        try!( self.read_bytes( &mut slice ) );
        Ok( self.context().endianness().read_u16( &slice ) )
    }

    #[inline]
    fn read_i16( &mut self ) -> io::Result< i16 > {
        let mut slice: [u8; 2] = unsafe { mem::uninitialized() };
        try!( self.read_bytes( &mut slice ) );
        Ok( self.context().endianness().read_i16( &slice ) )
    }

    #[inline]
    fn read_u32( &mut self ) -> io::Result< u32 > {
        let mut slice: [u8; 4] = unsafe { mem::uninitialized() };
        try!( self.read_bytes( &mut slice ) );
        Ok( self.context().endianness().read_u32( &slice ) )
    }

    #[inline]
    fn read_i32( &mut self ) -> io::Result< i32 > {
        let mut slice: [u8; 4] = unsafe { mem::uninitialized() };
        try!( self.read_bytes( &mut slice ) );
        Ok( self.context().endianness().read_i32( &slice ) )
    }

    #[inline]
    fn read_u64( &mut self ) -> io::Result< u64 > {
        let mut slice: [u8; 8] = unsafe { mem::uninitialized() };
        try!( self.read_bytes( &mut slice ) );
        Ok( self.context().endianness().read_u64( &slice ) )
    }

    #[inline]
    fn read_i64( &mut self ) -> io::Result< i64 > {
        let mut slice: [u8; 8] = unsafe { mem::uninitialized() };
        try!( self.read_bytes( &mut slice ) );
        Ok( self.context().endianness().read_i64( &slice ) )
    }

    #[inline]
    fn read_f32( &mut self ) -> io::Result< f32 > {
        let mut slice: [u8; 4] = unsafe { mem::uninitialized() };
        try!( self.read_bytes( &mut slice ) );
        Ok( self.context().endianness().read_f32( &slice ) )
    }

    #[inline]
    fn read_f64( &mut self ) -> io::Result< f64 > {
        let mut slice: [u8; 8] = unsafe { mem::uninitialized() };
        try!( self.read_bytes( &mut slice ) );
        Ok( self.context().endianness().read_f64( &slice ) )
    }

    #[inline]
    fn read_value< T: Readable< 'a, C > >( &mut self ) -> io::Result< T > {
        T::read_from( self )
    }

    #[inline]
    fn endianness( &self ) -> Endianness {
        self.context().endianness()
    }
}