Struct rlp::RlpStream[][src]

pub struct RlpStream { /* fields omitted */ }

Appendable rlp encoder.

Implementations

impl RlpStream[src]

pub fn new() -> Self[src]

Initializes instance of empty Stream.

pub fn new_list(len: usize) -> Self[src]

Initializes the Stream as a list.

pub fn new_with_buffer(buffer: BytesMut) -> Self[src]

Initializes instance of empty Stream.

pub fn new_list_with_buffer(buffer: BytesMut, len: usize) -> Self[src]

Initializes the Stream as a list.

pub fn append_empty_data(&mut self) -> &mut Self[src]

Apends null to the end of stream, chainable.

use rlp::RlpStream;
let mut stream = RlpStream::new_list(2);
stream.append_empty_data().append_empty_data();
let out = stream.out();
assert_eq!(out, vec![0xc2, 0x80, 0x80]);

pub fn append_raw(&mut self, bytes: &[u8], item_count: usize) -> &mut Self[src]

Appends raw (pre-serialised) RLP data. Use with caution. Chainable.

pub fn append<E>(&mut self, value: &E) -> &mut Self where
    E: Encodable
[src]

Appends value to the end of stream, chainable.

use rlp::RlpStream;
let mut stream = RlpStream::new_list(2);
stream.append(&"cat").append(&"dog");
let out = stream.out();
assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);

pub fn append_iter<I>(&mut self, value: I) -> &mut Self where
    I: IntoIterator<Item = u8>, 
[src]

Appends iterator to the end of stream, chainable.

use rlp::RlpStream;
let mut stream = RlpStream::new_list(2);
stream.append(&"cat").append_iter("dog".as_bytes().iter().cloned());
let out = stream.out();
assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);

pub fn append_list<E, K>(&mut self, values: &[K]) -> &mut Self where
    E: Encodable,
    K: Borrow<E>, 
[src]

Appends list of values to the end of stream, chainable.

pub fn append_internal<E>(&mut self, value: &E) -> &mut Self where
    E: Encodable
[src]

Appends value to the end of stream, but do not count it as an appended item. It’s useful for wrapper types

pub fn begin_list(&mut self, len: usize) -> &mut RlpStream[src]

Declare appending the list of given size, chainable.

use rlp::RlpStream;
let mut stream = RlpStream::new_list(2);
stream.begin_list(2).append(&"cat").append(&"dog");
stream.append(&"");
let out = stream.out();
assert_eq!(out, vec![0xca, 0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g', 0x80]);

pub fn begin_unbounded_list(&mut self) -> &mut RlpStream[src]

Declare appending the list of unknown size, chainable.

pub fn append_raw_checked(
    &mut self,
    bytes: &[u8],
    item_count: usize,
    max_size: usize
) -> bool
[src]

Appends raw (pre-serialised) RLP data. Checks for size overflow.

pub fn estimate_size(&self, add: usize) -> usize[src]

Calculate total RLP size for appended payload.

pub fn len(&self) -> usize[src]

Returns current RLP size in bytes for the data pushed into the list.

pub fn is_empty(&self) -> bool[src]

pub fn clear(&mut self)[src]

Clear the output stream so far.

use rlp::RlpStream;
let mut stream = RlpStream::new_list(3);
stream.append(&"cat");
stream.clear();
stream.append(&"dog");
let out = stream.out();
assert_eq!(out, vec![0x83, b'd', b'o', b'g']);

pub fn is_finished(&self) -> bool[src]

Returns true if stream doesnt expect any more items.

use rlp::RlpStream;
let mut stream = RlpStream::new_list(2);
stream.append(&"cat");
assert_eq!(stream.is_finished(), false);
stream.append(&"dog");
assert_eq!(stream.is_finished(), true);
let out = stream.out();
assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);

pub fn as_raw(&self) -> &[u8][src]

Get raw encoded bytes

pub fn out(self) -> BytesMut[src]

Streams out encoded bytes.

panic! if stream is not finished.

pub fn encoder(&mut self) -> BasicEncoder<'_>[src]

pub fn finalize_unbounded_list(&mut self)[src]

Finalize current unbounded list. Panics if no unbounded list has been opened.

Trait Implementations

impl Default for RlpStream[src]

Auto Trait Implementations

impl RefUnwindSafe for RlpStream

impl Send for RlpStream

impl Sync for RlpStream

impl Unpin for RlpStream

impl UnwindSafe for RlpStream

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.