Struct rlp::Rlp
[−]
[src]
pub struct Rlp<'a> { /* fields omitted */ }
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.
Methods
impl<'a, 'view> Rlp<'a> where
'a: 'view,
[src]
'a: 'view,
fn new(bytes: &'a [u8]) -> Rlp<'a>
[src]
Create a new instance of Rlp
fn as_raw(&'view self) -> &'a [u8]
[src]
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']); }
fn prototype(&self) -> Prototype
[src]
Get the prototype of the RLP.
fn payload_info(&self) -> PayloadInfo
[src]
Get payload info.
fn data(&'view self) -> &'a [u8]
[src]
Get underlieing data.
fn item_count(&self) -> usize
[src]
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); }
fn size(&self) -> usize
[src]
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); }
fn at(&'view self, index: usize) -> Rlp<'a>
[src]
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()); }
fn is_null(&self) -> bool
[src]
No value
extern crate rlp; use rlp::*; fn main () { let data = vec![]; let rlp = Rlp::new(&data); assert!(rlp.is_null()); }
fn is_empty(&self) -> bool
[src]
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()); }
fn is_list(&self) -> bool
[src]
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()); }
fn is_data(&self) -> bool
[src]
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()); }
fn is_int(&self) -> bool
[src]
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); }
fn iter(&'view self) -> RlpIterator<'a, 'view>
[src]
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(); }
fn as_val<T>(&self) -> T where
T: Decodable,
[src]
T: Decodable,
Decode data into an object
fn as_list<T>(&self) -> Vec<T> where
T: Decodable,
[src]
T: Decodable,
fn val_at<T>(&self, index: usize) -> T where
T: Decodable,
[src]
T: Decodable,
Decode data at given list index into an object
fn list_at<T>(&self, index: usize) -> Vec<T> where
T: Decodable,
[src]
T: Decodable,
Trait Implementations
impl<'a> From<UntrustedRlp<'a>> for Rlp<'a>
[src]
fn from(rlp: UntrustedRlp<'a>) -> Rlp<'a>
[src]
Performs the conversion.
impl<'a> Debug for Rlp<'a>
[src]
impl<'a> Display for Rlp<'a>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter. Read more
impl<'a, 'view> IntoIterator for &'view Rlp<'a> where
'a: 'view,
[src]
'a: 'view,