rsbx 2.0.0

Enhanced implementation of SeqBox in Rust
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

use reed_solomon_erasure::ReedSolomon;
use smallvec::SmallVec;
use sbx_block;
use sbx_specs::{Version,
                SBX_LARGEST_BLOCK_SIZE,
                ver_to_block_size,
                ver_uses_rs};

pub struct RSEncoder {
    index    : usize,
    rs_codec : ReedSolomon,
    version  : Version,
    par_buf  : SmallVec<[SmallVec<[u8; SBX_LARGEST_BLOCK_SIZE]>; 32]>,
    active   : bool,
}

macro_rules! mark_active {
    (
        $self:ident
    ) => {{
        $self.active = true;
    }}
}

macro_rules! mark_inactive {
    (
        $self:ident
    ) => {{
        $self.active = false;
    }}
}

macro_rules! incre_index {
    (
        $self:ident
    ) => {{
        $self.index += 1;
    }}
}

macro_rules! reset_index {
    (
        $self:ident
    ) => {{
        $self.index = 0;
    }}
}

macro_rules! codec_ready {
    (
        $self:ident
    ) => {{
        $self.index == $self.rs_codec.data_shard_count()
    }}
}

impl RSEncoder {
    pub fn new(version       : Version,
               data_shards   : usize,
               parity_shards : usize) -> RSEncoder {
        assert!(ver_uses_rs(version));

        let block_size = ver_to_block_size(version);

        let par_buf : SmallVec<[SmallVec<[u8; SBX_LARGEST_BLOCK_SIZE]>; 32]> =
            smallvec![smallvec![0; block_size]; parity_shards];

        RSEncoder {
            index    : 0,
            rs_codec : ReedSolomon::new(data_shards,
                                        parity_shards).unwrap(),
            version,
            par_buf,
            active : false,
        }
    }

    pub fn active(&self) -> bool {
        self.active
    }

    pub fn unfilled_slot_count(&self) -> usize {
        self.total_slot_count() - self.index
    }

    pub fn total_slot_count(&self) -> usize {
        self.rs_codec.data_shard_count()
    }

    pub fn encode_no_block_sync(&mut self,
                                data : &[u8])
                                -> Option<&mut SmallVec<[SmallVec<[u8; SBX_LARGEST_BLOCK_SIZE]>; 32]>> {
        let data = sbx_block::slice_data_buf(self.version, data);

        let version  = self.version;
        let rs_codec = &self.rs_codec;
        let par_buf  = &mut self.par_buf;

        {
            let mut parity : SmallVec<[&mut [u8]; 32]> =
                SmallVec::with_capacity(par_buf.len());

            for p in par_buf.iter_mut() {
                parity.push(sbx_block::slice_data_buf_mut(version, p));
            }
            rs_codec.encode_single_sep(self.index,
                                       data,
                                       &mut parity).unwrap();
        }

        incre_index!(self);

        if codec_ready!(self) {
            reset_index!(self);
            mark_inactive!(self);
            Some(par_buf)
        } else {
            mark_active!(self);
            None
        }
    }
}