Struct Marshaller

pub struct Marshaller<'a, C, D>
where
    C: AsRef<[u8]>,
    D: AsRef<[u8]>,
    Self: 'a,
{ /* private fields */ }

Marshals instructions to and from bytecode representation.

Implementations

impl<'a> Marshaller<'a, Vec<u8>, Vec<u8>>

where Self: 'a,

pub fn new(libs: &'a LibsSeg) -> Self

Creates a new marshaller using provided set of libraries.

pub fn finish(self) -> (SmallBlob, SmallBlob)

Completes marshalling, returning produced data segment.

Panics

If marshaller position is not at byte margin.

impl<'a, C, D> Marshaller<'a, C, D>

where C: AsRef<[u8]>, D: AsRef<[u8]>, Self: 'a,

pub fn with(bytecode: C, data: D, libs: &'a LibsSeg) -> Self

Create marshaller from byte string utilizing existing bytecode.

Panics

If the length of the bytecode or data segment exceeds 0xFF.

pub const fn offset(&self) -> (u16, u3)

Returns the current offset of the marshaller

Trait Implementations

impl<'a, C, D> BytecodeRead<LibId> for Marshaller<'a, C, D>

where C: AsRef<[u8]>, D: AsRef<[u8]>, Self: 'a,

fn pos(&self) -> u16

Return the current byte offset of the cursor. Does not account for bits. If the position is exactly at EOF, returns None.

fn seek(&mut self, byte_pos: u16) -> Result<u16, CodeEofError>

Set the current cursor byte offset to the provided value if it is less than the underlying buffer length.

fn is_eof(&self) -> bool

Return whether end of the bytecode is reached.

fn peek_byte(&self) -> Result<u8, CodeEofError>

Peek a single byte without moving cursor.

fn read_bool(&mut self) -> Result<bool, CodeEofError>

Read single bit as a bool value.

fn read_1bit(&mut self) -> Result<u1, CodeEofError>

Read single bit.

fn read_2bits(&mut self) -> Result<u2, CodeEofError>

Read two bits.

fn read_3bits(&mut self) -> Result<u3, CodeEofError>

Read three bits.

fn read_4bits(&mut self) -> Result<u4, CodeEofError>

Read four bits.

fn read_5bits(&mut self) -> Result<u5, CodeEofError>

Read five bits.

fn read_6bits(&mut self) -> Result<u6, CodeEofError>

Read six bits.

fn read_7bits(&mut self) -> Result<u7, CodeEofError>

Read seven bits.

fn read_byte(&mut self) -> Result<u8, CodeEofError>

Read byte.

fn read_word(&mut self) -> Result<u16, CodeEofError>

Read word.

fn read_fixed<N, const LEN: usize>( &mut self, f: impl FnOnce([u8; LEN]) -> N, ) -> Result<N, CodeEofError>

Read the fixed number of bytes and convert it into a result type.

fn read_bytes(&mut self) -> Result<(SmallBlob, bool), CodeEofError>

Read variable-length byte string.

fn read_ref(&mut self) -> Result<LibId, CodeEofError>

where LibId: Sized,

Read external reference id.

fn check_aligned(&self)

Check if the current cursor position is aligned to the next byte.

impl<'a, C, D> BytecodeWrite<LibId> for Marshaller<'a, C, D>

where C: AsRef<[u8]> + AsMut<[u8]> + Extend<u8>, D: AsRef<[u8]> + AsMut<[u8]> + Extend<u8>, Self: 'a,

type Error = MarshallError

Error type returned during writing procedures.

fn write_1bit(&mut self, data: u1) -> Result<(), MarshallError>

Write a single bit.

fn write_2bits(&mut self, data: u2) -> Result<(), MarshallError>

Write two bits.

fn write_3bits(&mut self, data: u3) -> Result<(), MarshallError>

Write three bits.

fn write_4bits(&mut self, data: u4) -> Result<(), MarshallError>

Write four bits.

fn write_5bits(&mut self, data: u5) -> Result<(), MarshallError>

Write five bits.

fn write_6bits(&mut self, data: u6) -> Result<(), MarshallError>

Write six bits.

fn write_7bits(&mut self, data: u7) -> Result<(), MarshallError>

Write seven bits.

fn write_byte(&mut self, data: u8) -> Result<(), MarshallError>

Write byte.

fn write_word(&mut self, data: u16) -> Result<(), MarshallError>

Write word.

fn write_fixed<const LEN: usize>( &mut self, data: [u8; LEN], ) -> Result<(), Self::Error>

Write data representable as a fixed-length byte array.

fn write_bytes(&mut self, data: &[u8]) -> Result<(), Self::Error>

Write variable-length byte string.

fn write_ref(&mut self, id: LibId) -> Result<(), Self::Error>

Write external reference id.

fn check_aligned(&self)

Check if the current cursor position is aligned to the next byte.

fn write_bool(&mut self, data: bool) -> Result<(), Self::Error>

Write a single bit from a bool value.

impl<'a, C, D> Debug for Marshaller<'a, C, D>

where C: AsRef<[u8]>, D: AsRef<[u8]>, Self: 'a,

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

Formats the value using the given formatter.