Struct craftio_rs::CraftWriter

pub struct CraftWriter<W> { /* fields omitted */ }

Wraps some stream of type W, and implements either CraftSyncWriter or CraftAsyncWriter (or both) based on what types W implements.

You can construct this type calling the function wrap_with_state, which requires you to specify a packet direction (are written packets server-bound or client-bound?) and a state (handshaking? login? status? play?).

This type holds some internal buffers but only allocates them when they are required.

Implementations

impl<W> CraftWriter<W>

pub fn wrap(inner: W, direction: PacketDirection) -> Self

pub fn wrap_with_state(
    inner: W,
    direction: PacketDirection,
    state: State
) -> Self

Trait Implementations

impl<W> CraftAsyncWriter for CraftWriter<W> where
    W: AsyncWriteAll, 

pub fn write_packet_async<'life0, 'async_trait, P>(
    &'life0 mut self,
    packet: P
) -> Pin<Box<dyn Future<Output = WriteResult<()>> + Send + 'async_trait>> where
    P: Packet + Send + Sync,
    P: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Attempts to serialize, and then write a packet struct to the wrapped stream.

pub fn write_raw_packet_async<'a, 'life0, 'async_trait, P>(
    &'life0 mut self,
    packet: P
) -> Pin<Box<dyn Future<Output = WriteResult<()>> + Send + 'async_trait>> where
    P: RawPacket<'a> + Send + Sync,
    'a: 'async_trait,
    P: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Attempts to write a serialized packet to the wrapped stream.

impl<W> CraftIo for CraftWriter<W>

pub fn set_state(&mut self, next: State)

Changes the current connection state. For readers, this changes how numeric packet IDs are interpreted. For writers, this will change the packets that can be written without a panic.

pub fn set_compression_threshold(&mut self, threshold: Option<i32>)

Modifies the compression configuration. If a value of None is provided, then compression is disabled. If a value of Some is provided, then the threshold is set to that value.

pub fn enable_encryption(
    &mut self,
    key: &[u8],
    iv: &[u8]
) -> Result<(), CipherError>

Modifies the encryption configuration. This function should only be called once, and can only be used to enable encryption.

pub fn set_max_packet_size(&mut self, max_size: usize)

Sets the max packet size which this I/O wrapper will decode or transmit.

pub fn ensure_buf_capacity(&mut self, capacity: usize)

pub fn ensure_compression_buf_capacity(&mut self, capacity: usize)

impl<W> CraftSyncWriter for CraftWriter<W> where
    W: Write, 

pub fn write_packet<P>(&mut self, packet: P) -> WriteResult<()> where
    P: Packet, 

Attempts to serialize, and then write a packet struct to the wrapped stream.

pub fn write_raw_packet<'a, P>(&mut self, packet: P) -> WriteResult<()> where
    P: RawPacket<'a>, 

Attempts to write a serialized packet to the wrapped stream

impl<W> CraftWrapper<W> for CraftWriter<W>

pub fn into_inner(self) -> W

Unwraps the wrapped value of type I, and drops the wrapper type