bit_manager 0.2.0

A crate for reading and writing bits from various streams
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Provides converters for reading and writing values using stucts

use super::*;
use std::io;
use std::mem;

/// A trait for reading values using a converter
pub trait BitRead<T>: Sized {
    /// Read a value from the given reader
    fn read_value_from<R: io::Read>(&self, reader: &mut BitReader<R>) -> Result<T>;
}

/// A trait for writing values using a converter
pub trait BitWrite<T>: Sized {
    /// Write a value to the given writer
    fn write_value_to<W: io::Write>(&self, value: T, writer: &mut BitWriter<W>) -> Result<()>;
}

/// A struct that allows writing non-bit-length numbers
#[derive(Debug)]
pub struct BitMask {
    bits: u8,
}

impl BitMask {
    /// Creates a mask with the given number of bits.
    pub fn bits(bits: u8) -> BitMask {
        BitMask {
            bits,
        }
    }

    /// Creates a mask with the given number of bytes.
    pub fn bytes(bytes: u8) -> BitMask {
        BitMask {
            bits: bytes*8,
        }
    }
}

impl BitReadable for BitMask {
    fn read_from<R: io::Read>(reader: &mut BitReader<R>) -> Result<BitMask> {
        match reader.read_byte() {
            Ok(bits) => Ok(BitMask { bits }),
            Err(e) => Err(e),
        }
    }
}

impl BitWritable for BitMask {
    fn write_to<W: io::Write>(self, writer: &mut BitWriter<W>) -> Result<()> {
        writer.write_byte(self.bits)
    }
}

impl<'a> BitWritable for &'a BitMask {
    fn write_to<W: io::Write>(self, writer: &mut BitWriter<W>) -> Result<()> {
        writer.write_byte(self.bits)
    }
}

macro_rules! impl_bit_mask {
    ($( $u: ident $i: ident $b: expr ),+) => { $(
        impl BitRead<$u> for BitMask {
            fn read_value_from<R: io::Read>(&self, reader: &mut BitReader<R>) -> Result<$u> {
                if self.bits > $b {
                    return Err(Error::ConversionFailed);
                } else if self.bits == 0 {
                    return Ok(0);
                }
                let mut int = 0;
                for index in 0..self.bits {
                    let read = reader.read_bit()?;
                    if read {
                        int |= 1 << (self.bits-index-1);
                    }
                }
                Ok($u::from_le(int))
            }
        }

        impl BitRead<$i> for BitMask {
            fn read_value_from<R: io::Read>(&self, reader: &mut BitReader<R>) -> Result<$i> {
                unsafe { Ok(mem::transmute::<$u, $i>(self.read_value_from(reader)?)) }
            }
        }

        impl BitWrite<$u> for BitMask {
            fn write_value_to<W: io::Write>(&self, value: $u, writer: &mut BitWriter<W>) -> Result<()> {
                if self.bits != 0 {
                    let int = u64::to_le(value as u64);
                    if self.bits < 64 && int >> self.bits != 0 {
                        return Err(Error::ConversionFailed);
                    }
                    for index in 0..self.bits {
                        writer.write_bit((int >> (self.bits - index - 1)) & 1 == 1)?;
                    }
                }
                Ok(())
            }
        }

        impl BitWrite<$i> for BitMask {
            fn write_value_to<W: io::Write>(&self, value: $i, writer: &mut BitWriter<W>) -> Result<()> {
                unsafe { self.write_value_to(mem::transmute::<$i, $u>(value), writer) }
            }
        }
    )+ }
}

impl_bit_mask!(u64 i64 64, u32 i32 32, u16 i16 16, u8 i8 8);

///// A trait for a struct that can be converted to a `Vec` of bits
//pub trait ToBits: Sized {
//    /// Returns this as a series of bits.
//    fn to_bits(&self) -> Vec<bool>;
//}
//
///// A trait for a struct that can be converted to a `Vec` of bytes
//pub trait ToBytes: Sized {
//    fn to_bytes(&self) -> Vec<u8>;
//}
//
//impl<T: ToBytes> ToBits for T {
//    fn to_bits(&self) -> Vec<bool> {
//        let bytes = self.to_bytes();
//        let mut bits = Vec::with_capacity(bytes.len()*8);
//        for byte in bytes {
//            for index in 0..8 {
//                bits.push((byte >> 7-index) & 1 == 1);
//            }
//        }
//        bits
//    }
//}