binator_stream 0.0.0

binator stream
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use core::{
  mem::size_of,
  ops::{
    BitAnd,
    Shl,
  },
};

use binator_core::{
  SplitError,
  SplitFirst,
  UtilsStream,
};
use num_traits::One;

const fn bits_of<Item>() -> usize {
  size_of::<Item>() * u8::BITS as usize
}

#[derive(Clone, PartialEq, Eq)]
pub struct BitStream<Stream: UtilsStream, Item = <Stream as UtilsStream>::Item> {
  stream: Stream,
  i: usize,
  cur: Item,
}

impl<Stream> From<Stream> for BitStream<Stream>
where
  Stream: UtilsStream,
  <Stream as UtilsStream>::Item: Default,
{
  fn from(stream: Stream) -> Self {
    Self::new(stream)
  }
}

impl<Stream: UtilsStream> BitStream<Stream> {
  pub fn new(stream: Stream) -> Self
  where
    <Stream as UtilsStream>::Item: Default,
  {
    Self {
      stream,
      i: bits_of::<<Stream as UtilsStream>::Item>(),
      cur: Default::default(),
    }
  }

  fn next(self) -> (bool, Self)
  where
    for<'a> &'a <Stream as UtilsStream>::Item: BitAnd<Token = <Stream as UtilsStream>::Item>,
    <Stream as UtilsStream>::Item: Shl<usize, Token = <Stream as UtilsStream>::Item>,
    <Stream as UtilsStream>::Item: PartialEq,
    <Stream as UtilsStream>::Item: One,
  {
    let flag = <Stream as UtilsStream>::Item::one() << self.i;
    (
      &self.cur & &flag == flag,
      Self {
        stream: self.stream,
        i: self.i + 1,
        cur: self.cur,
      },
    )
  }

  pub fn into_stream(self) -> Stream {
    self.stream
  }
}

impl<Stream: UtilsStream> UtilsStream for BitStream<Stream> {
  type Error = <Stream as UtilsStream>::Error;
  type Item = bool;
}

impl<Stream: SplitFirst> SplitFirst for BitStream<Stream>
where
  for<'a> &'a <Stream as UtilsStream>::Item: BitAnd<Token = <Stream as UtilsStream>::Item>,
  <Stream as UtilsStream>::Item: Shl<usize, Token = <Stream as UtilsStream>::Item>,
  <Stream as UtilsStream>::Item: PartialEq,
  <Stream as UtilsStream>::Item: One,
{
  fn split_first(self) -> Result<(Self::Item, Self), SplitError<Self, Self::Error>> {
    if self.i == bits_of::<<Stream as UtilsStream>::Item>() {
      let (cur, stream) = self.stream.split_first().map_err(|e| {
        e.map(|stream| {
          Self {
            stream,
            i: self.i,
            cur: self.cur,
          }
        })
      })?;

      Ok(
        Self {
          stream,
          i: 0,
          cur,
        }
        .next(),
      )
    } else {
      Ok(self.next())
    }
  }
}

// impl<Reader: Read, const N: usize> Subset for BitStream<Reader, N> {
//   fn subset(&self, other: &Self) -> Option<Self> {
//     match (&self.position, &other.position) {
//       (Position::RangeFrom(a), Position::RangeFrom(b)) => self.range(a.start,
// b.start),       (Position::RangeFrom(a), Position::Range(b)) =>
// self.range(a.start, b.start),       (Position::Range(a),
// Position::RangeFrom(b)) => self.range(a.start, b.start),       (Position::
// Range(a), Position::Range(b)) => self.range(a.start, b.start),     }
//   }
// }

// impl<Reader: Read, const N: usize> SplitEnd for BitStream<Reader, N> {
//   fn split_end(self) -> Result<(Self, Self), (Self::Error, Self)> {
//     match &self.position {
//       Position::RangeFrom(range) => {
//         let ret = self.buf.borrow_mut().read_all();
//         match ret {
//           Ok(end) => {
//             let empty = Self {
//               buf: self.buf.clone(),
//               position: Position::Range(end..end),
//             };
//             Ok((
//               Self {
//                 buf: self.buf,
//                 position: Position::Range(range.start..end),
//               },
//               empty,
//             ))
//           }
//           Err(error) => Err((error, self)),
//         }
//       }
//       Position::Range(range) => {
//         let empty = Self {
//           buf: self.buf.clone(),
//           position: Position::Range(range.end..range.end),
//         };
//         Ok((self, empty))
//       }
//     }
//   }
// }