Struct MemWordWriterSlice 

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

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

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

Examples

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: AsRef<[W]>> MemWordWriterSlice<W, B>

pub const fn new(data: B) -> Self

Creates a new MemWordWriterSlice from a slice.

pub fn len(&self) -> usize

Returns the number of words in the underlying slice.

pub fn is_empty(&self) -> bool

Returns true if the underlying slice is empty.

pub fn into_inner(self) -> B

Consumes this writer and returns the underlying data.

Trait Implementations

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

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

Formats the value using the given formatter.

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

where B: MemSize + FlatType, usize: MemSize + FlatType, PhantomData<W>: MemSize + FlatType,

type Flat = False

Whether the type is flat (True) or not (False).

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

where B: MemDbgImpl + FlatType, usize: MemDbgImpl + FlatType, PhantomData<W>: MemDbgImpl + FlatType,

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, _memdbg_refs: &mut HashSet<usize>, ) -> Result

Recursively displays the fields of self below the current line.

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, dbg_refs: &mut HashSet<usize>, ) -> Result<(), Error>

Displays self at the given depth without any reference-address annotation; forwards to _mem_dbg_depth_on_impl with RefDisplay::None.

fn _mem_dbg_depth_on_impl( &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, dbg_refs: &mut HashSet<usize>, ref_display: RefDisplay, ) -> Result<(), Error>

Internal implementation for depth display.

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

where B: MemSize + FlatType, usize: MemSize + FlatType, PhantomData<W>: MemSize + FlatType,

fn mem_size_rec( &self, _memsize_flags: SizeFlags, _memsize_refs: &mut HashMap<usize, usize>, ) -> usize

Recursive implementation that tracks visited references for deduplication.

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

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

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

fn eq(&self, other: &MemWordWriterSlice<W, B>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<W: PartialEq + Word, B: PartialEq> StructuralPartialEq for MemWordWriterSlice<W, B>

impl<W: Word, B: AsRef<[W]>> WordRead for MemWordWriterSlice<W, B>

type Error = WordError

type Word = W

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

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

Reads a word and advances the current position.

fn read_word_opt(&mut self) -> Option<Self::Word>

Reads and consumes the next word if the backend can determine cheaply that one is available, returning None otherwise (in particular, at the end of the stream, or when availability cannot be determined without blocking or performing I/O).

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

type Error = WordError

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

Gets the current position in words from the start of the stream.

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

Sets the current position in words from the start of the stream to word_pos.

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

type Error = WordError

type Word = W

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

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

Writes a word and advances the current position.

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

Flushes the stream.