Struct Packet 

pub struct Packet<'de, T>
where
    T: Serialize + Deserialize<'de>,
{ /* private fields */ }

Generic packet format.

Useful for game servers and the like.

Packet supports writing to anything that implements Write, and reading from anything that implements Read. including std::net::TcpStreams.

Currently it will not work with std::net::UdpSocket since it does not implement Write or Read.

Packet supports a payload of any value that implements serde::Serialize and serde::Deserialize.

The chomp_packet function allows you to read a packet from a Reader and will return a serialized string of the packet, use Packet::deserialize to deserialize it.

Packet::unwrap will give you the original payload stored in the packet.

Examples

use serde::{Serialize, Deserialize};
use std::io::Cursor;
use xuko_net::packet::{Packet, chomp_packet};

#[derive(Serialize, Deserialize)]
struct Payload {
    x: i32,
    y: f32
}

let packet = Packet::new(Payload {
    x: 6,
    y: 3.14
});

let mut stream = Cursor::new(Vec::new());

packet.send(&mut stream); // Write to a stream
packet.unwrap(); // Unwrap the original value using `Packet::unwrap`

Implementations

impl<'de, T: Serialize + Deserialize<'de>> Packet<'de, T>

pub const fn new(payload: T) -> Self

Create a new Packet

Examples found in repository

examples/packet_sync.rs (line 52)

fn client() -> Result<(), PacketError> {
    let mut stream = TcpStream::connect(ADDRESS)?;

    Packet::new(ExamplePacket::SendInfo("Hello!".to_string())).send(&mut stream)?;

    Ok(())
}

pub fn unwrap(self) -> T

Unwrap the Packet to its underlying type

Examples found in repository

examples/packet_sync.rs (line 38)

fn server() -> Result<(), PacketError> {
    let listener = TcpListener::bind(ADDRESS)?;

    while let Ok((mut stream, addr)) = listener.accept() {
        println!("request from: {addr}");

        let packet = chomp_packet(&mut stream)?;
        println!("received packet: {packet}");

        let parsed = Packet::<ExamplePacket>::deserialize(&packet)?.unwrap();

        match parsed {
            ExamplePacket::GetHardcodedValue => unreachable!(),
            ExamplePacket::SendInfo(s) => println!("This is what the packet contained: {s}"),
        }
    }

    Ok(())
}

pub fn serialize(&self) -> Result<String, Error>

Serialize Packet into a String

pub fn deserialize(serialized: &'de str) -> Result<Packet<'de, T>, Error>

Deserialize a string into a Packet

Examples found in repository

examples/packet_sync.rs (line 38)

fn server() -> Result<(), PacketError> {
    let listener = TcpListener::bind(ADDRESS)?;

    while let Ok((mut stream, addr)) = listener.accept() {
        println!("request from: {addr}");

        let packet = chomp_packet(&mut stream)?;
        println!("received packet: {packet}");

        let parsed = Packet::<ExamplePacket>::deserialize(&packet)?.unwrap();

        match parsed {
            ExamplePacket::GetHardcodedValue => unreachable!(),
            ExamplePacket::SendInfo(s) => println!("This is what the packet contained: {s}"),
        }
    }

    Ok(())
}

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

Write the Packet in its serialized form to a writer

Examples found in repository

examples/packet_sync.rs (line 52)

fn client() -> Result<(), PacketError> {
    let mut stream = TcpStream::connect(ADDRESS)?;

    Packet::new(ExamplePacket::SendInfo("Hello!".to_string())).send(&mut stream)?;

    Ok(())
}