Trait tor_bytes::Writer[−][src]

pub trait Writer {
    fn write_all(&mut self, b: &[u8]);

    fn write_u8(&mut self, x: u8) { ... }

    fn write_u16(&mut self, x: u16) { ... }

    fn write_u32(&mut self, x: u32) { ... }

    fn write_u64(&mut self, x: u64) { ... }

    fn write_u128(&mut self, x: u128) { ... }

    fn write_zeros(&mut self, n: usize) { ... }

    fn write<E: Writeable + ?Sized>(&mut self, e: &E) { ... }

    fn write_and_consume<E: WriteableOnce>(&mut self, e: E) { ... }
}
Expand description

A byte-oriented trait for writing to small arrays.

Unlike std::io::Write, this trait’s methods are not allowed to fail. It’s not for IO.

Most code will want to use the fact that Vec implements this trait. To define a new implementation, just define the write_all method.

Examples

You can use a Writer to add bytes explicitly:

use tor_bytes::Writer;
let mut w: Vec<u8> = Vec::new(); // Vec<u8> implements Writer.
w.write_u32(0x12345);
w.write_u8(0x22);
w.write_zeros(3);
assert_eq!(w, &[0x00, 0x01, 0x23, 0x45, 0x22, 0x00, 0x00, 0x00]);

You can also use a Writer to encode things that implement the Writeable trait:

use tor_bytes::{Writer,Writeable};
let mut w: Vec<u8> = Vec::new();
w.write(&4_u16); // The unsigned types all implement Writeable.

// We also provide Writeable implementations for several important types.
use std::net::Ipv4Addr;
let ip = Ipv4Addr::new(127, 0, 0, 1);
w.write(&ip);

assert_eq!(w, &[0x00, 0x04, 0x7f, 0x00, 0x00, 0x01]);

Required methods

Append a slice to the end of this writer.

Provided methods

Append a single u8 to this writer.

Append a single u16 to this writer, encoded in big-endian order.

Append a single u32 to this writer, encoded in big-endian order.

Append a single u64 to this writer, encoded in big-endian order.

Append a single u128 to this writer, encoded in big-endian order.

Write n bytes to this writer, all with the value zero.

NOTE: This implementation is somewhat inefficient, since it allocates a vector. You should probably replace it if you can.

Encode a Writeable object onto this writer, using its write_onto method.

Encode a WriteableOnce object onto this writer, using its write_into method.

Implementations on Foreign Types

Vec is the main type that implements Writer.

Implementors