Struct RebuiltSource 

pub struct RebuiltSource<'a> { /* private fields */ }

The input a parse decodes to, rebuilt from its literals as it is read, as a decoder would (C ZSTD_compressSequencesAndLiterals takes the literals rather than the input). Matches reaching before the start read from dict; literals past the last sequence are the trailing ones. Only the last window bytes are held for the matches to copy from (more only while a match reaching further, into the dictionary, is being copied), so a frame is built from it without the whole input in memory.

use structured_zstd::encoding::sequences::{ExternalSequence, RebuiltSource};
use std::io::Read;
let parse = [
    ExternalSequence { offset: 3, lit_len: 3, match_len: 6, rep: 0 },
    ExternalSequence { offset: 0, lit_len: 1, match_len: 0, rep: 0 },
];
let mut source = RebuiltSource::new(&parse, b"abc!", &[], 1 << 10).unwrap();
assert_eq!(source.len(), 10);
let mut out = Vec::new();
source.read_to_end(&mut out).unwrap();
assert_eq!(out, b"abcabcabc!");

Implementations

impl<'a> RebuiltSource<'a>

pub fn new( sequences: &'a [ExternalSequence], literals: &'a [u8], dict: &'a [u8], window: usize, ) -> Result<Self, SequenceError>

Check that sequences and literals rebuild to a whole input with every match within the output so far plus dict while the output is within window, and within window after (as validate_parse checks), and set up to read it.

Errors

SequenceError::LengthMismatch when the sequences need more literals than there are, SequenceError::OffsetTooFar when a match reaches further back than that, SequenceError::ZeroOffset for a match at offset 0.

pub fn len(&self) -> usize

Bytes the source rebuilds in all.

pub fn is_empty(&self) -> bool

Whether the source rebuilds nothing.

Trait Implementations

impl Read for RebuiltSource<'_>

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_, u8>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact( &mut self, cursor: BorrowedCursor<'_, u8>, ) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

🔬This is a nightly-only experimental API. (read_array)

Read and return a fixed array of bytes from this source.

fn read_le<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in little-endian order.

fn read_be<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in big-endian order.