Struct Rlp 

pub struct Rlp<'a> { /* private fields */ }

Data-oriented view onto trusted rlp-slice.

Unlikely to UntrustedRlp doesn’t bother you with error handling. It assumes that you know what you are doing.

Implementations

impl<'a, 'view> Rlp<'a>

where 'a: 'view,

pub fn new(bytes: &'a [u8]) -> Rlp<'a>

Create a new instance of Rlp

pub fn as_raw(&'view self) -> &'a [u8]

The raw data of the RLP as slice.

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
	let rlp = Rlp::new(&data);
	let dog = rlp.at(1).as_raw();
	assert_eq!(dog, &[0x83, b'd', b'o', b'g']);
}

pub fn prototype(&self) -> Prototype

Get the prototype of the RLP.

pub fn payload_info(&self) -> PayloadInfo

Get payload info.

pub fn data(&'view self) -> &'a [u8]

Get underlieing data.

pub fn item_count(&self) -> usize

Returns number of RLP items.

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
	let rlp = Rlp::new(&data);
	assert_eq!(rlp.item_count(), 2);
	let view = rlp.at(1);
	assert_eq!(view.item_count(), 0);
}

pub fn size(&self) -> usize

Returns the number of bytes in the data, or zero if it isn’t data.

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
	let rlp = Rlp::new(&data);
	assert_eq!(rlp.size(), 0);
	let view = rlp.at(1);
	assert_eq!(view.size(), 3);
}

pub fn at(&'view self, index: usize) -> Rlp<'a>

Get view onto RLP-slice at index.

Caches offset to given index, so access to successive slices is faster.

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
	let rlp = Rlp::new(&data);
	let dog: String = rlp.at(1).as_val();
	assert_eq!(dog, "dog".to_string());
}

pub fn is_null(&self) -> bool

No value

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![];
	let rlp = Rlp::new(&data);
	assert!(rlp.is_null());
}

pub fn is_empty(&self) -> bool

Contains a zero-length string or zero-length list.

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![0xc0];
	let rlp = Rlp::new(&data);
	assert!(rlp.is_empty());
}

pub fn is_list(&self) -> bool

List value

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
	let rlp = Rlp::new(&data);
	assert!(rlp.is_list());
}

pub fn is_data(&self) -> bool

String value

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
	let rlp = Rlp::new(&data);
	assert!(rlp.at(1).is_data());
}

pub fn is_int(&self) -> bool

Int value

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![0xc1, 0x10];
	let rlp = Rlp::new(&data);
	assert_eq!(rlp.is_int(), false);
	assert_eq!(rlp.at(0).is_int(), true);
}

pub fn iter(&'view self) -> RlpIterator<'a, 'view>

Get iterator over rlp-slices

extern crate rlp;
use rlp::*;

fn main () {
	let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
	let rlp = Rlp::new(&data);
	let strings: Vec<String> = rlp.iter().map(| i | i.as_val()).collect();
}

pub fn as_val<T>(&self) -> T

where T: Decodable,

Decode data into an object

pub fn as_list<T>(&self) -> Vec<T>

where T: Decodable,

pub fn val_at<T>(&self, index: usize) -> T

where T: Decodable,

Decode data at given list index into an object

pub fn list_at<T>(&self, index: usize) -> Vec<T>

where T: Decodable,

Trait Implementations

impl<'a> Debug for Rlp<'a>

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

Formats the value using the given formatter.

impl<'a> Display for Rlp<'a>

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

Formats the value using the given formatter.

impl<'a> From<UntrustedRlp<'a>> for Rlp<'a>

fn from(rlp: UntrustedRlp<'a>) -> Rlp<'a>

Converts to this type from the input type.

impl<'a, 'view> IntoIterator for &'view Rlp<'a>

where 'a: 'view,

type Item = Rlp<'a>

The type of the elements being iterated over.

type IntoIter = RlpIterator<'a, 'view>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.