Struct CellParser

pub struct CellParser<'a> {
    pub cell: &'a Cell,
    /* private fields */
}

Fields

cell: &'a Cell

Implementations

impl<'a> CellParser<'a>

pub fn new(cell: &'a Cell) -> Self

pub fn remaining_bits(&mut self) -> usize

pub fn remaining_refs(&self) -> usize

pub fn remaining_bytes(&mut self) -> usize

Return number of full bytes remaining

pub fn load_bit(&mut self) -> Result<bool, TonCellError>

pub fn seek(&mut self, num_bits: i64) -> Result<(), TonCellError>

pub fn load_u8(&mut self, bit_len: usize) -> Result<u8, TonCellError>

pub fn load_i8(&mut self, bit_len: usize) -> Result<i8, TonCellError>

pub fn load_u16(&mut self, bit_len: usize) -> Result<u16, TonCellError>

pub fn load_i16(&mut self, bit_len: usize) -> Result<i16, TonCellError>

pub fn load_u32(&mut self, bit_len: usize) -> Result<u32, TonCellError>

pub fn load_i32(&mut self, bit_len: usize) -> Result<i32, TonCellError>

pub fn load_u64(&mut self, bit_len: usize) -> Result<u64, TonCellError>

pub fn load_i64(&mut self, bit_len: usize) -> Result<i64, TonCellError>

pub fn load_uint(&mut self, bit_len: usize) -> Result<BigUint, TonCellError>

pub fn load_int(&mut self, bit_len: usize) -> Result<BigInt, TonCellError>

pub fn load_byte(&mut self) -> Result<u8, TonCellError>

pub fn load_slice(&mut self, slice: &mut [u8]) -> Result<(), TonCellError>

pub fn load_bytes(&mut self, num_bytes: usize) -> Result<Vec<u8>, TonCellError>

pub fn load_ref_cell_optional( &mut self, ) -> Result<Option<ArcCell>, TonCellError>

pub fn load_bits_to_slice( &mut self, num_bits: usize, slice: &mut [u8], ) -> Result<(), TonCellError>

pub fn load_bits(&mut self, bit_len: usize) -> Result<Vec<u8>, TonCellError>

pub fn load_utf8(&mut self, num_bytes: usize) -> Result<String, TonCellError>

pub fn load_coins(&mut self) -> Result<BigUint, TonCellError>

pub fn load_remaining(&mut self) -> Result<Cell, TonCellError>

pub fn load_msg_address(&mut self) -> Result<MsgAddress, TonCellError>

pub fn load_address(&mut self) -> Result<TonAddress, TonCellError>

pub fn load_unary_length(&mut self) -> Result<usize, TonCellError>

pub fn load_dict_data<K: Eq + Hash, V>( &mut self, key_len: usize, key_reader: KeyReader<K>, val_reader: ValReader<V>, ) -> Result<HashMap<K, V>, TonCellError>

pub fn load_dict<K: Eq + Hash, V>( &mut self, key_len: usize, key_reader: KeyReader<K>, val_reader: ValReader<V>, ) -> Result<HashMap<K, V>, TonCellError>

pub fn load_dict_snake_format( &mut self, ) -> Result<SnakeFormatDict, TonCellError>

Snake format when we store part of the data in a cell and the rest of the data in the first child cell (and so recursively).

Must be prefixed with 0x00 byte.

TL-B scheme:

tail#_ {bn:#} b:(bits bn) = SnakeData ~0;

cons#_ {bn:#} {n:#} b:(bits bn) next:^(SnakeData ~n) = SnakeData ~(n + 1);

pub fn load_dict_data_snake_format( &mut self, ) -> Result<SnakeFormatDict, TonCellError>

pub fn ensure_empty(&mut self) -> Result<(), TonCellError>

pub fn load_remaining_data_aligned(&mut self) -> Result<Vec<u8>, TonCellError>

pub fn load_snake_format_aligned( &mut self, has_prefix: bool, ) -> Result<Vec<u8>, TonCellError>

pub fn skip_bits(&mut self, num_bits: usize) -> Result<(), TonCellError>

pub fn load_number<N: TonCellNum>( &mut self, bit_len: usize, ) -> Result<N, TonCellError>

pub fn load_number_optional<N: TonCellNum>( &mut self, bit_len: usize, ) -> Result<Option<N>, TonCellError>

pub fn next_reference(&mut self) -> Result<ArcCell, TonCellError>

pub fn load_either_cell_or_cell_ref(&mut self) -> Result<ArcCell, TonCellError>

pub fn load_maybe_cell_ref(&mut self) -> Result<Option<ArcCell>, TonCellError>

pub fn load_tlb<T: TLB>(&mut self) -> Result<T, TonCellError>

pub fn load_tonhash(&mut self) -> Result<TonHash, TonCellError>