set_encoding/
lib.rs

1extern crate int;
2extern crate bitrw;
3extern crate tbe;
4extern crate num_traits;
5
6pub trait UniversalSet {
7    type T: int::UInt;
8    fn size(self) -> Self::T;
9}
10
11///
12pub trait OrderedSet {
13    type T: int::UInt;
14    /// 0 <= value_size()
15    fn value_size(&self) -> Self::T;
16    /// 0 <= size() <= value_size()
17    fn size(&self) -> Self::T;
18    /// 0 <= i < size()
19    /// 0 <= get(i) < value_size()
20    fn get(&self, i: Self::T) -> Self::T;
21}
22
23///
24pub trait OrderedSetBuilder {
25    type T: int::UInt;
26    fn add(&mut self, i: Self::T, value: Self::T);
27}
28
29pub trait CreateOrderedSet: Copy {
30    type T: int::UInt;
31    type B: OrderedSetBuilder<T = Self::T>;
32    type S: OrderedSet<T = Self::T>;
33    fn value_size(self) -> Self::T;
34    fn new(self, size: Self::T, f: &mut FnMut(&mut Self::B) -> std::io::Result<()>) -> std::io::Result<Self::S>;
35}
36
37struct Range2D<T: int::UInt> {
38    pub offset: T,
39    pub size: T,
40    pub value_offset: T,
41    pub value_size: T,
42}
43
44impl<T: int::UInt> Range2D<T> {
45    fn next_i(&self) -> T {
46        self.size >> 1u8
47    }
48    fn split(self, i: T, value_i: T) -> (Self, Self) {
49        let j = i + T::_1;
50        let value_j = value_i + T::_1;
51        (   Range2D {
52                offset: self.offset,
53                size: i,
54                value_offset: self.value_offset,
55                value_size: value_i
56            },
57            Range2D {
58                offset: self.offset + j,
59                size: self.size - j,
60                value_offset: self.value_offset + value_j,
61                value_size: self.value_size - value_j
62            }
63        )
64    }
65    fn tbe(&self) -> tbe::TbeStruct<T> {
66        use tbe::Tbe;
67        (self.value_size - self.size + T::_1).tbe()
68    }
69    fn new(size: T, value_size: T) -> Self {
70        Self { offset: T::_0, size: size, value_offset: T::_0, value_size: value_size }
71    }
72}
73
74pub trait WriteSet {
75    fn ordered_set_write<S: OrderedSet>(self, s: &S) -> std::io::Result<()>;
76}
77
78struct WriteFrame<'t, 'b, S: OrderedSet> {
79    set: &'t S,
80    w: &'t mut bitrw::BitWrite<'b>,
81}
82
83impl<S: OrderedSet> WriteFrame<'_, '_, S> {
84    fn subset_write(&mut self, range: Range2D<S::T>) -> std::io::Result<()> {
85        use int::UInt;
86        if S::T::_0 < range.size && range.size < range.value_size {
87            use tbe::TbeWrite;
88            use num_traits::cast::AsPrimitive;
89            let i = range.next_i();
90            let value_i = self.set.get(range.offset + i) - range.value_offset;
91            self.w.write_tbe(range.tbe(), value_i - i)?;
92            let (left, right) = range.split(i, value_i);
93            self.subset_write(left)?;
94            self.subset_write(right)?;
95        }
96        Ok(())
97    }
98}
99
100impl WriteSet for &mut bitrw::BitWrite<'_> {
101    fn ordered_set_write<S: OrderedSet>(self, s: &S) -> std::io::Result<()> {
102        use tbe::Tbe;
103        use tbe::TbeWrite;
104        let size = s.size();
105        let value_size = s.value_size();
106        self.write_tbe(value_size.tbe(), size)?;
107        let mut x = WriteFrame { set: s, w: self };
108        x.subset_write(Range2D::new(size, value_size))?;
109        Ok(())
110    }
111}
112
113pub trait ReadSet {
114    fn ordered_set_read<C: CreateOrderedSet>(&mut self, c: C) -> std::io::Result<C::S>;
115}
116
117struct ReadFrame<'t, 'b, B: OrderedSetBuilder> {
118    builder: &'t mut B,
119    r: &'t mut bitrw::BitRead<'b>,
120}
121
122impl<B: OrderedSetBuilder> ReadFrame<'_, '_, B> {
123    fn subset_read(&mut self, range: Range2D<B::T>) -> std::io::Result<()> {
124        use int::UInt;
125        if B::T::_0 < range.size && range.size <= range.value_size {
126            use tbe::TbeRead;
127            let i = range.next_i();
128            let value_i = self.r.read_tbe(range.tbe())? + i;
129            self.builder.add(range.offset + i, range.value_offset + value_i);
130            let (left, right) = range.split(i, value_i);
131            self.subset_read(left)?;
132            self.subset_read(right)?;
133        }
134        Ok(())
135    }
136}
137
138impl ReadSet for bitrw::BitRead<'_> {
139    fn ordered_set_read<C: CreateOrderedSet>(&mut self, c: C) -> std::io::Result<C::S> {
140        use tbe::TbeRead;
141        use tbe::Tbe;
142        let value_size = c.value_size();
143        let size = self.read_tbe(value_size.tbe())?;
144        c.new(size, &mut |b| {
145            ReadFrame { builder: b, r: self }.subset_read(Range2D::new(size, value_size))
146        })
147    }
148}
set_encoding/lib.rs

set_encoding/
lib.rs
