Struct ontio_std::abi::Source

pub struct Source<'a> { /* fields omitted */ }

Parse data of bytearray type into original data type

Implementations

impl<'a> Source<'a>

pub fn new(data: &'a [u8]) -> Self

Create a new source instance

Example

  let mut sink = Sink::new(0);
  sink.write("123");
  let mut source = Source::new(sink.bytes());
  let res:&str = source.read().unwrap_or_default();
  assert_eq!(res, "123");

pub fn read_bytes(&mut self) -> Result<&'a [u8], Error>

read bytearray

Example

  let mut sink = Sink::new(0);
  sink.write("123".as_bytes());
  let mut source = Source::new(sink.bytes());
  let res= source.read_bytes().unwrap_or_default();
  assert_eq!(res, "123".as_bytes());

pub fn read<T: Decoder<'a>>(&mut self) -> Result<T, Error>

Parse the bytearray data into the original data type. The original data type must implement the decoder interface.

Example

  let mut sink = Sink::new(0);
  sink.write("123");
  sink.write(123 as U128);
  let mut source = Source::new(sink.bytes());
  let res:&str= source.read().unwrap();
  let res2 :U128 = source.read().unwrap();
  assert_eq!(res as &str, "123");
  assert_eq!(res2, 123 as U128);

pub fn read_address(&mut self) -> Result<&'a Address, Error>

pub fn read_native_address(&mut self) -> Result<&'a Address, Error>

pub fn read_native_varuint(&mut self) -> Result<u64, Error>

pub fn read_h256(&mut self) -> Result<&'a H256, Error>

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

read byte.

Example

  let mut sink = Sink::new(0);
  sink.write(b'1');
  let mut source = Source::new(sink.bytes());
  let res= source.read_byte().unwrap_or_default();
  assert_eq!(res, b'1');

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

read bool.

Example

let mut sink = Sink::new(0);
sink.write(true);
let mut source = Source::new(sink.bytes());
let res= source.read_bool().unwrap_or_default();
assert_eq!(res, true);

pub fn skip(&mut self, n: usize) -> Result<(), Error>

Skip specified long bytes.

Example

  let mut sink = Sink::new(0);
  let addr = Address::repeat_byte(1);
  sink.write(addr);
  sink.write(123 as U128);
  let mut source = Source::new(sink.bytes());
  source.skip(20);//the length of addr is 20
  let res = source.read_u128().unwrap_or_default();
  assert_eq!(res, 123 as U128);

pub fn backup(&mut self, n: usize)

Back specified length of bytes.

Example

  let mut sink = Sink::new(0);
  let addr = Address::repeat_byte(1);
  sink.write(123 as U128);
  let mut source = Source::new(sink.bytes());
  source.read_byte();//Read a byte of data here
  source.backup(1);//Back one byte
  let res = source.read_u128().unwrap_or_default();
  assert_eq!(res, 123 as U128);

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

Read u16 type data.

Example

  let mut sink = Sink::new(0);
  let addr = Address::repeat_byte(1);
  sink.write(123u16);
  let mut source = Source::new(sink.bytes());
  let res = source.read_u16().unwrap_or_default();
  assert_eq!(res, 123u16);

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

Read u32 type data.

Example

  let mut sink = Sink::new(0);
  let addr = Address::repeat_byte(1);
  sink.write(123u32);
  let mut source = Source::new(sink.bytes());
  let res = source.read_u32().unwrap_or_default();
  assert_eq!(res, 123u32);

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

Read u64 type data.

Example

  let mut sink = Sink::new(0);
  let addr = Address::repeat_byte(1);
  sink.write(123u64);
  let mut source = Source::new(sink.bytes());
  let res = source.read_u64().unwrap_or_default();
  assert_eq!(res, 123u64);

pub fn read_u128(&mut self) -> Result<u128, Error>

Read u128 type data.

Example

  let mut sink = Sink::new(0);
  let addr = Address::repeat_byte(1);
  sink.write(123 as U128);
  let mut source = Source::new(sink.bytes());
  let res = source.read_u128().unwrap_or_default();
  assert_eq!(res, 123 as U128);

pub fn read_varuint(&mut self) -> Result<u64, Error>