Struct assembly_pack::sd0::read::SegmentedDecoder

pub struct SegmentedDecoder<T> { /* private fields */ }

Available on crate feature sd0 only.

A sd0 streamed file

use assembly_pack::sd0::read::SegmentedDecoder;
use std::io::{Cursor, Read};

const BYTES: [u8; 30] = [
    0x73, 0x64, 0x30, 0x01, 0xff, 0x15, 0x00, 0x00,
    0x00, 0x78, 0xda, 0xf3, 0x48, 0xcd, 0xc9, 0xc9,
    0x57, 0x08, 0xcf, 0x2f, 0xca, 0x49, 0x51, 0xe4,
    0x02, 0x00, 0x20, 0x91, 0x04, 0x48,
];

let mut decoder = SegmentedDecoder::new(Cursor::new(&BYTES)).unwrap();
let mut output = String::new();
decoder.read_to_string(&mut output).unwrap();
assert_eq!(output, "Hello World!\n");

Implementations

impl<T> SegmentedDecoder<T>

pub fn into_inner(self) -> T

Get the inner reader

This panics when the value is invalid, which only happens when a read failed.

pub fn get_mut(&mut self) -> &mut T

Get a mutable reference to the inner stream

impl<T: Read> SegmentedDecoder<T>

pub fn new(inner: T) -> Result<Self>

Create a new reader

Trait Implementations

impl<T: Read> Read for SegmentedDecoder<T>

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

Read from the (decompressed) stream

This may leave the

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<'_>) -> 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<'_>) -> 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” adaptor 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.