Struct ShardByShard 

pub struct ShardByShard<'a, F: 'a + Field> { /* private fields */ }

Bookkeeper for shard by shard encoding.

This is useful for avoiding incorrect use of encode_single and encode_single_sep

Use cases

Shard by shard encoding is useful for streamed data encoding where you do not have all the needed data shards immediately, but you want to spread out the encoding workload rather than doing the encoding after everything is ready.

A concrete example would be network packets encoding, where encoding packet by packet as you receive them may be more efficient than waiting for N packets then encode them all at once.

Example

use rustfs_erasure_codec::galois_8::Field;
let r: ReedSolomon<Field> = ReedSolomon::new(3, 2).unwrap();

let mut sbs = ShardByShard::new(&r);

let mut shards = shards!([0u8,  1,  2,  3,  4],
                         [5,  6,  7,  8,  9],
                         // say we don't have the 3rd data shard yet
                         // and we want to fill it in later
                         [0,  0,  0,  0,  0],
                         [0,  0,  0,  0,  0],
                         [0,  0,  0,  0,  0]);

// encode 1st and 2nd data shard
sbs.encode(&mut shards).unwrap();
sbs.encode(&mut shards).unwrap();

// fill in 3rd data shard
shards[2][0] = 10.into();
shards[2][1] = 11.into();
shards[2][2] = 12.into();
shards[2][3] = 13.into();
shards[2][4] = 14.into();

// now do the encoding
sbs.encode(&mut shards).unwrap();

assert!(r.verify(&shards).unwrap());

Implementations

impl<'a, F: 'a + Field> ShardByShard<'a, F>

pub fn new(codec: &'a ReedSolomon<F>) -> ShardByShard<'a, F>

Create a new shard-by-shard encoder.

pub fn parity_ready(&self) -> bool

Returns true if all data shards have been encoded and parity is ready.

pub fn reset(&mut self) -> Result<(), SBSError>

Reset to accept a new batch of data shards.

Returns SBSError::LeftoverShards if the previous batch was incomplete.

pub fn reset_force(&mut self)

Force-reset without checking for leftover shards.

pub fn cur_input_index(&self) -> usize

Returns the index of the next data shard expected.

pub fn encode<T, U>(&mut self, shards: T) -> Result<(), SBSError>

where T: AsRef<[U]> + AsMut<[U]>, U: AsRef<[F::Elem]> + AsMut<[F::Elem]>,

Encode the next data shard in the batch.

pub fn encode_sep<T: AsRef<[F::Elem]>, U: AsRef<[F::Elem]> + AsMut<[F::Elem]>>( &mut self, data: &[T], parity: &mut [U], ) -> Result<(), SBSError>

Encode the next data shard using separate data and parity slices.

Trait Implementations

impl<'a, F: Debug + 'a + Field> Debug for ShardByShard<'a, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, F: PartialEq + 'a + Field> PartialEq for ShardByShard<'a, F>

fn eq(&self, other: &ShardByShard<'a, F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, F: PartialEq + 'a + Field> StructuralPartialEq for ShardByShard<'a, F>