Struct MemWordWriterSlice

pub struct MemWordWriterSlice<W: Word, B: AsMut<[W]>> { /* private fields */ }

An implementation of WordRead, WordWrite, and WordSeek for a mutable slice.

Writing beyond the end of the slice will return an error.

Example

use dsi_bitstream::prelude::*;

let mut words: [u64; 2] = [
    0x0043b59fcdf16077,
    0x702863e6f9739b86,
];

let mut word_writer = MemWordWriterSlice::new(&mut words);

// the stream is read sequentially
assert_eq!(word_writer.word_pos()?, 0);
assert_eq!(word_writer.read_word()?, 0x0043b59fcdf16077);
assert_eq!(word_writer.word_pos()?, 1);
assert_eq!(word_writer.read_word()?, 0x702863e6f9739b86);
assert_eq!(word_writer.word_pos()?, 2);
assert!(word_writer.read_word().is_err());

// you can change position
assert!(word_writer.set_word_pos(1).is_ok());
assert_eq!(word_writer.word_pos()?, 1);
assert_eq!(word_writer.read_word()?, 0x702863e6f9739b86);

// errored set position doesn't change the current position
assert_eq!(word_writer.word_pos()?, 2);
assert!(word_writer.set_word_pos(100).is_err());
assert_eq!(word_writer.word_pos()?, 2);

// we can write and read back!
assert!(word_writer.set_word_pos(0).is_ok());
assert!(word_writer.write_word(0x0b801b2bf696e8d2).is_ok());
assert_eq!(word_writer.word_pos()?, 1);
assert!(word_writer.set_word_pos(0).is_ok());
assert_eq!(word_writer.read_word()?, 0x0b801b2bf696e8d2);
assert_eq!(word_writer.word_pos()?, 1);

Implementations

impl<W: Word, B: AsMut<[W]> + AsRef<[W]>> MemWordWriterSlice<W, B>

pub fn new(data: B) -> Self

Create a new MemWordWriterSlice from a slice of ZERO INITIALIZED data

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn into_inner(self) -> B

Trait Implementations

impl<W: Word, B> CopyType for MemWordWriterSlice<W, B>

where B: MemSize + AsMut<[W]>, usize: MemSize, PhantomData<W>: MemSize,

type Copy = False

impl<W: Debug + Word, B: Debug + AsMut<[W]>> Debug for MemWordWriterSlice<W, B>

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

Formats the value using the given formatter.

impl<W: Word, B> MemDbgImpl for MemWordWriterSlice<W, B>

where B: MemDbgImpl + AsMut<[W]>, usize: MemDbgImpl, PhantomData<W>: MemDbgImpl,

fn _mem_dbg_rec_on( &self, _memdbg_writer: &mut impl Write, _memdbg_total_size: usize, _memdbg_max_depth: usize, _memdbg_prefix: &mut String, _memdbg_is_last: bool, _memdbg_flags: DbgFlags, ) -> Result

fn _mem_dbg_depth_on( &self, writer: &mut impl Write, total_size: usize, max_depth: usize, prefix: &mut String, field_name: Option<&str>, is_last: bool, padded_size: usize, flags: DbgFlags, ) -> Result<(), Error>

impl<W: Word, B> MemSize for MemWordWriterSlice<W, B>

where B: MemSize + AsMut<[W]>, usize: MemSize, PhantomData<W>: MemSize,

fn mem_size(&self, _memsize_flags: SizeFlags) -> usize

Returns the (recursively computed) overall memory size of the structure in bytes.

impl<W: PartialEq + Word, B: PartialEq + AsMut<[W]>> PartialEq for MemWordWriterSlice<W, B>

fn eq(&self, other: &MemWordWriterSlice<W, B>) -> 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<W: Word, B: AsMut<[W]>> WordRead for MemWordWriterSlice<W, B>

type Error = Error

type Word = W

The word type (the type of the result of WordRead::read_word).

fn read_word(&mut self) -> Result<W, Error>

Read a word and advance the current position.

impl<W: Word, B: AsRef<[W]> + AsMut<[W]>> WordSeek for MemWordWriterSlice<W, B>

type Error = Error

fn word_pos(&mut self) -> Result<u64, Error>

Get the current position in words from the start of the file.

fn set_word_pos(&mut self, word_index: u64) -> Result<(), Error>

Set the current position in words from the start of the file to word_pos.

impl<W: Word, B: AsMut<[W]>> WordWrite for MemWordWriterSlice<W, B>

type Error = Error

type Word = W

The word type (the type of the argument of WordWrite::write_word).

fn write_word(&mut self, word: W) -> Result<(), Error>

Write a word and advance the current position.

fn flush(&mut self) -> Result<(), Self::Error>

Flush the stream.

impl<W: Word, B: AsMut<[W]>> StructuralPartialEq for MemWordWriterSlice<W, B>