Trait RateDecoder 

pub trait RateDecoder<E: Engine>
where
    Self: Sized,
{
    type Rate: Rate<E>;

    // Required methods
    fn add_original_shard<T: AsRef<[u8]>>(
        &mut self,
        index: usize,
        original_shard: T,
    ) -> Result<(), Error>;
    fn add_recovery_shard<T: AsRef<[u8]>>(
        &mut self,
        index: usize,
        recovery_shard: T,
    ) -> Result<(), Error>;
    fn decode(
        &mut self,
        compute_recovery: bool,
    ) -> Result<Option<DecoderResult<'_>>, Error>;
    fn into_parts(self) -> (E, DecoderWork);
    fn new(
        original_count: usize,
        recovery_count: usize,
        shard_bytes: usize,
        engine: E,
        work: Option<DecoderWork>,
    ) -> Result<Self, Error>;
    fn reset(
        &mut self,
        original_count: usize,
        recovery_count: usize,
        shard_bytes: usize,
    ) -> Result<(), Error>;
    fn validate(
        original_count: usize,
        recovery_count: usize,
        shard_bytes: usize,
    ) -> Result<(), Error>;

    // Provided method
    fn supports(original_count: usize, recovery_count: usize) -> bool { ... }
}

Reed-Solomon decoder using specific rate.

Required Associated Types

type Rate: Rate<E>

Rate of this decoder.

Required Methods

fn add_original_shard<T: AsRef<[u8]>>( &mut self, index: usize, original_shard: T, ) -> Result<(), Error>

Like Decoder::add_original_shard.

fn add_recovery_shard<T: AsRef<[u8]>>( &mut self, index: usize, recovery_shard: T, ) -> Result<(), Error>

Like Decoder::add_recovery_shard.

fn decode( &mut self, compute_recovery: bool, ) -> Result<Option<DecoderResult<'_>>, Error>

Like Decoder::decode, this reconstructs the missing shards, or returns Ok(None) if every original was already provided (nothing to reconstruct). When compute_recovery is set, the missing recovery shards are also reconstructed into the work buffers. The returned DecoderResult exposes only restored original shards, so callers of this trait should pass false. Reconstructed recovery shards are readable through Decoder::decode_with_recovery and Decoder::decode_with_recovery_plan.

fn into_parts(self) -> (E, DecoderWork)

Consumes this decoder returning its Engine and DecoderWork so that they can be re-used by another decoder.

fn new( original_count: usize, recovery_count: usize, shard_bytes: usize, engine: E, work: Option<DecoderWork>, ) -> Result<Self, Error>

Like Decoder::new with Engine to use and optional working space to be re-used.

fn reset( &mut self, original_count: usize, recovery_count: usize, shard_bytes: usize, ) -> Result<(), Error>

Like Decoder::reset.

fn validate( original_count: usize, recovery_count: usize, shard_bytes: usize, ) -> Result<(), Error>

Checks that the shard counts are supported, the shard size is nonzero and even, and this decoder’s working space fits in a single allocation.

Provided Methods

fn supports(original_count: usize, recovery_count: usize) -> bool

Returns true if given original_count / recovery_count combination is supported.

This is same as Rate::supports.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<E: Engine> RateDecoder<E> for DefaultRateDecoder<E>

type Rate = DefaultRate<E>

impl<E: Engine> RateDecoder<E> for HighRateDecoder<E>

type Rate = HighRate<E>

impl<E: Engine> RateDecoder<E> for LowRateDecoder<E>

type Rate = LowRate<E>