Struct concordium_std::ContractState

pub struct ContractState { /* fields omitted */ }

A type representing the constract state bytes.

Trait Implementations

impl Default for ContractState

pub fn default() -> ContractState

Returns the "default value" for a type.

impl HasContractState<()> for ContractState

type ContractStateData = ()

pub fn open(_: Self::ContractStateData) -> Self

Open the contract state. Only one instance can be opened at the same time.

pub fn reserve(&mut self, len: u32) -> bool

Make sure that the memory size is at least that many bytes in size. Returns true iff this was successful. The new bytes are initialized as 0.

pub fn size(&self) -> u32

Get the current size of contract state.

pub fn truncate(&mut self, new_size: u32)

Truncate the state to the given size. If the given size is more than the current state size this operation does nothing. The new position is at most at the end of the stream.

impl Read for ContractState

pub 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).

pub fn read_u64(&mut self) -> ParseResult<u64>

Read a u32 in little-endian format. This is optimized to not initialize a dummy value before calling an external function.

pub fn read_u32(&mut self) -> ParseResult<u32>

Read a u32 in little-endian format. This is optimized to not initialize a dummy value before calling an external function.

pub fn read_u8(&mut self) -> ParseResult<u8>

Read a u8 in little-endian format. This is optimized to not initialize a dummy value before calling an external function.

pub 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.

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

Read a u16 in little-endian format.

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

Read a i64 in little-endian format.

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

Read a i32 in little-endian format.

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

Read a i16 in little-endian format.

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

Read a i32 in little-endian format.

impl Seek for ContractState

Contract state trait implementations.

type Err = ()

pub fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Err>

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

impl Write for ContractState

type Err = ()

pub 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.

pub 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.

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

Write a single byte to the output.

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

Write a u16 in little endian.

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

Write a u32 in little endian.

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

Write a u64 in little endian.

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

Write a i8 to the output.

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

Write a i16 in little endian.

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

Write a i32 in little endian.

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

Write a i64 in little endian.