Struct concordium_std::test_infrastructure::TestStateEntry

pub struct TestStateEntry { /* private fields */ }

👎Deprecated since 8.1.0: Deprecated in favor of concordium-smart-contract-testing.

A state entry used for testing. Implements HasStateEntry.

Trait Implementations

impl Debug for TestStateEntry

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

Formats the value using the given formatter.

impl HasStateEntry for TestStateEntry

fn size(&self) -> Result<u32, Self::Error>

Get the size of the data in the entry. Returns an error if the entry has been deleted with delete_prefix.

fn truncate(&mut self, new_size: u32) -> Result<(), Self::Error>

Truncate the entry. Returns an error if the entry has been deleted with delete_prefix.

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

Get a reference to the key.

fn resize(&mut self, new_size: u32) -> Result<(), Self::Error>

Resize the entry. Returns an error if the entry has been deleted with delete_prefix.

type Error = TestStateError

type StateEntryData = Rc<RefCell<TestStateEntryData>>

type StateEntryKey = Vec<u8>

fn move_to_start(&mut self)

Set the cursor to the beginning. Equivalent to .seek(SeekFrom::Start(0)) but can be implemented more efficiently.

fn reserve(&mut self, len: u32) -> Result<(), Self::Error>

Make sure that the memory size is at least that many bytes in size. Returns Ok iff this was successful. The new bytes are initialized as 0. Returns an error if the entry does not exist.

impl Read for TestStateEntry

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

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 Seek for TestStateEntry

type Err = TestStateError

fn seek(&mut self, pos: SeekFrom) -> Result<u32, Self::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 TestStateEntry

type Err = TestStateError

fn write(&mut self, buf: &[u8]) -> Result<usize, Self::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.