Struct VarWriter 

pub struct VarWriter { /* private fields */ }

A writer for sending several segments over a stream using variable length encoding Data is written in little-endian if the feature “big-endian” is not enabled

Example

use send_it::writer::VarWriter;

let mut sender = VarWriter::new();

sender.add_string("Hello");
sender.add_string("World");

let mut buffer = Vec::new();
sender.send(&mut buffer).unwrap();

Implementations

impl VarWriter

pub fn new() -> VarWriter

Create a new VarWriter

pub fn add(&mut self, segment: Segment)

Add a segment to the writer

pub fn add_string<S: Into<String>>(&mut self, string: S)

Add a string to the writer

Example

use send_it::writer::VarWriter;

let mut sender = VarWriter::new();

sender.add_string("Hello");

Examples found in repository

examples/client.rs (line 9)

fn main() {
    // create a connection to our example server in server.rs
    let mut connection = std::net::TcpStream::connect("localhost:3333").expect("Failed to connect to server!");
    
    // create a writer
    let mut writer = send_it::writer::VarWriter::default();
    
    // add two segments: "Hello, " and "world!"
    writer.add_string("Hello, ");
    writer.add_string("world!");
    
    // send our two segments to the TcpStream and exit
    writer.send(&mut connection).expect("Failed to send data!");
    println!("sent data!");
}

pub fn add_raw(&mut self, raw: &[u8])

Add raw data to the writer

Example

use send_it::writer::VarWriter;

let mut sender = VarWriter::new();

sender.add_raw(&[0x48, 0x65, 0x6C, 0x6C, 0x6F]);

pub fn send<W: Write>(&mut self, stream: &mut W) -> Result<()>

Encodes the data and sends it over the stream.

• The data is cleared after sending.

Example

use send_it::writer::VarWriter;

let mut sender = VarWriter::new();

sender.add_string("Hello");
sender.add_string("World");

let mut buffer = Vec::new();
sender.send(&mut buffer).unwrap();

Examples found in repository

examples/client.rs (line 13)

fn main() {
    // create a connection to our example server in server.rs
    let mut connection = std::net::TcpStream::connect("localhost:3333").expect("Failed to connect to server!");
    
    // create a writer
    let mut writer = send_it::writer::VarWriter::default();
    
    // add two segments: "Hello, " and "world!"
    writer.add_string("Hello, ");
    writer.add_string("world!");
    
    // send our two segments to the TcpStream and exit
    writer.send(&mut connection).expect("Failed to send data!");
    println!("sent data!");
}

pub fn send_without_clearing<W: Write>(&mut self, stream: &mut W) -> Result<()>

Encodes the data and sends it over the stream.

• The data is not cleared after sending.

Example

use send_it::writer::VarWriter;

let mut sender = VarWriter::new();

sender.add_string("Hello");
sender.add_string("World");

let mut buffer = Vec::new();
sender.send_without_clearing(&mut buffer).unwrap();

pub fn clear(&mut self)

Removes all segments from the writer

Trait Implementations

impl Default for VarWriter

fn default() -> Self

Returns the “default value” for a type.

impl Write for VarWriter

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.