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

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

pub struct BitIterator<I> {
    n: u32,
    i: u32,
    iter: I,
    byte: Option<u8>,
}

impl<I> BitIterator<I> {
    pub fn new(s: I) -> Self {
        BitIterator {
            n: 8,
            i: 0,
            iter: s,
            byte: None,
        }
    }
}

impl<I> Iterator for BitIterator<I>
where
    I: Read,
{
    type Item = u8;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            let bit = (self.i % self.n) as u8;
            self.i += 1;
            if bit == 0 {
                self.byte = None;
            }
            if self.byte == None {
                let mut b = 0;
                match self.iter.read(slice::from_mut(&mut b)) {
                    Ok(0) => None,
                    Ok(..) => {
                        self.byte = Some(b);
                        self.byte
                    }
                    Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
                    Err(_) => None,
                };
            }
            return self.byte.map(|b| (b >> bit) & 1);
        }
    }
}