Enum OutgoingPacket 

pub enum OutgoingPacket {
    Encrypted {
        opcode: u16,
        data: Bytes,
    },
    Simple {
        opcode: u16,
        data: Bytes,
    },
    Massive {
        opcode: u16,
        packets: Vec<Bytes>,
    },
}

A packet on its way out, before having been turned into a frame.

In turn, we still need to know what kind of frame it should end up as. Generally, one outgoing packet will result in a single frame, but multiple packets can be combined to a massive packet. This will span multiple frames, including an additional header.

Variants

Encrypted

A packet that shall be encrypted before being sent out.

Fields

opcode: u16

data: Bytes

Simple

A basic packet that doesn’t need any additional transformation.

Fields

opcode: u16

data: Bytes

Massive

A massive packet containing multiple inner packets that should be sent together.

Fields

opcode: u16

packets: Vec<Bytes>

Trait Implementations

impl AsFrames for OutgoingPacket

fn as_frames( &self, context: SecurityContext<'_>, ) -> Result<Vec<SilkroadFrame>, FramingError>

Creates a collection of SilkroadFrame that represent the given structure.

impl Debug for OutgoingPacket

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for OutgoingPacket

impl<T> From<T> for OutgoingPacket

where T: AsPacket,

fn from(value: T) -> OutgoingPacket

Converts to this type from the input type.

impl PartialEq for OutgoingPacket

fn eq(&self, other: &OutgoingPacket) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for OutgoingPacket