protocol 0.3.4

Easy protocol definitions
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

use {Parcel, Error, TryFromIntError};
use primitives::Integer;

use std::io::prelude::*;

/// The integer type that we will use to send length prefixes.
pub type SizeType = u32;

/// Reads a length-prefixed list from a stream.
pub fn read_list<T>(read: &mut Read)
    -> Result<Vec<T>, Error>
    where T: Parcel {
    self::read_list_ext::<SizeType, T>(read)
}

/// Writes a length-prefixed list to a stream.
pub fn write_list<'a,T,I>(write: &mut Write, elements: I)
    -> Result<(), Error>
    where T: Parcel+'a,
          I: IntoIterator<Item=&'a T> {
    self::write_list_ext::<SizeType, T, I>(write, elements)
}

pub fn read_list_ext<S,T>(read: &mut Read)
    -> Result<Vec<T>, Error>
    where S: Integer,
          T: Parcel {
    let size = S::read(read)?;
    let size: usize = size.to_usize().ok_or(TryFromIntError{ })?;
    let mut elements = Vec::with_capacity(size);

    for _ in 0..size {
        let element = T::read(read)?;
        elements.push(element);
    }
    Ok(elements)
}

pub fn write_list_ext<'a,S,T,I>(write: &mut Write, elements: I)
    -> Result<(), Error>
    where S: Integer,
          T: Parcel+'a,
          I: IntoIterator<Item=&'a T> {
    let elements: Vec<_> = elements.into_iter().collect();
    let length = S::from_usize(elements.len()).ok_or(TryFromIntError{ })?;
    length.write(write)?;

    for element in elements.into_iter() {
        element.write(write)?;
    }

    Ok(())
}