Struct concordium_std::Cursor

pub struct Cursor<T> {
    pub offset: usize,
    pub data: T,
}

Add offset tracking inside a data structure.

Fields

offset: usize

data: T

Implementations

impl<T> Cursor<T>

pub fn new(data: T) -> Cursor<T>

Trait Implementations

impl<T> AsRef<[u8]> for Cursor<T>

where T: AsRef<[u8]>,

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Debug for Cursor<T>

where T: Debug,

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

Formats the value using the given formatter.

impl HasCallResponse for Cursor<Vec<u8>>

fn size(&self) -> u32

Get the size of the call response to the contract invocation.

impl<T> Read for Cursor<T>

where T: AsRef<[u8]>,

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

Read a number of bytes into the provided buffer. The returned value is Ok(n) if a read was successful, and n bytes were read (n could be 0).

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

Read exactly the required number of bytes. If not enough bytes could be read the function returns Err(_), and the contents of the given buffer is unspecified.

fn read_u64(&mut self) -> Result<u64, ParseError>

Read a u64 in little-endian format.

fn read_u32(&mut self) -> Result<u32, ParseError>

Read a u32 in little-endian format.

fn read_u16(&mut self) -> Result<u16, ParseError>

Read a u16 in little-endian format.

fn read_u8(&mut self) -> Result<u8, ParseError>

Read a u8.

fn read_i64(&mut self) -> Result<i64, ParseError>

Read a i64 in little-endian format.

fn read_i32(&mut self) -> Result<i32, ParseError>

Read a i32 in little-endian format.

fn read_i16(&mut self) -> Result<i16, ParseError>

Read a i16 in little-endian format.

fn read_i8(&mut self) -> Result<i8, ParseError>

Read a i32 in little-endian format.

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

Load an array of the given size.

impl<T> Seek for Cursor<T>

where T: HasSize,

type Err = ()

fn seek(&mut self, pos: SeekFrom) -> Result<u32, <Cursor<T> as Seek>::Err>

Seek to the new position. If successful, return the new position from the beginning of the stream.

fn cursor_position(&self) -> u32

Get the cursor position counted from the beginning of the stream.

impl Write for Cursor<&mut Vec<u8>>

type Err = ()

fn write( &mut self, buf: &[u8] ) -> Result<usize, <Cursor<&mut Vec<u8>> as Write>::Err>

Try to write the given buffer into the output stream. If writes are successful returns the number of bytes written.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Err>

Attempt to write the entirety of the buffer to the output by repeatedly calling write until either no more output can written, or writing fails.

fn write_u8(&mut self, x: u8) -> Result<(), Self::Err>

Write a single byte to the output.

fn write_u16(&mut self, x: u16) -> Result<(), Self::Err>

Write a u16 in little endian.

fn write_u32(&mut self, x: u32) -> Result<(), Self::Err>

Write a u32 in little endian.

fn write_u64(&mut self, x: u64) -> Result<(), Self::Err>

Write a u64 in little endian.

fn write_i8(&mut self, x: i8) -> Result<(), Self::Err>

Write a i8 to the output.

fn write_i16(&mut self, x: i16) -> Result<(), Self::Err>

Write a i16 in little endian.

fn write_i32(&mut self, x: i32) -> Result<(), Self::Err>

Write a i32 in little endian.

fn write_i64(&mut self, x: i64) -> Result<(), Self::Err>

Write a i64 in little endian.