Struct PacketSink 

pub struct PacketSink<W> { /* private fields */ }

#Examples

use futures::io::Cursor;
use futures::executor::block_on;
use futures::sink::SinkExt;
use ssb_packetstream::*;

let mut sink = PacketSink::new(Cursor::new(vec![0u8; 14]));
block_on(async {
    sink.send(Packet::new(IsStream::Yes,
                          IsEnd::No,
                          BodyType::Json,
                          123,
                          vec![1,2,3,4,5])).await;
    sink.close().await;
    let buf = sink.into_inner().into_inner();
    assert_eq!(&buf, &[0b0000_1010,   // flags
                       0, 0, 0, 5,    // body length
                       0, 0, 0, 123,  // packet id
                       1, 2, 3, 4, 5, // body
                       0, 0, 0, 0, 0, 0, 0, 0, 0]); // goodbye packet
});

Implementations

impl<W> PacketSink<W>

pub fn new(w: W) -> PacketSink<W>

pub fn into_inner(self) -> W

Trait Implementations

impl<W> Sink<Packet> for PacketSink<W>

where W: AsyncWrite + Unpin + 'static,

type Error = Error

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: Packet) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.