Struct naia_shared::BaseConnection

pub struct BaseConnection<P: ProtocolType> { /* fields omitted */ }

Represents a connection to a remote host, and provides functionality to manage the connection and the communications to it

Implementations

impl<P: ProtocolType> BaseConnection<P>

pub fn new(address: SocketAddr, config: &ConnectionConfig) -> Self

Create a new BaseConnection, given the appropriate underlying managers

pub fn mark_sent(&mut self)

Record that a message has been sent (to prevent needing to send a heartbeat)

pub fn should_send_heartbeat(&self) -> bool

Returns whether a heartbeat message should be sent

pub fn mark_heard(&mut self)

Record that a message has been received from a remote host (to prevent disconnecting from the remote host)

pub fn should_drop(&self) -> bool

Returns whether this connection should be dropped as a result of a timeout

pub fn process_incoming_header(
    &mut self,
    header: &StandardHeader,
    packet_notifiable: &mut Option<&mut dyn PacketNotifiable>
)

Process an incoming packet, pulling out the packet index number to keep track of the current RTT, and sending the packet to the AckManager to handle packet notification events

pub fn process_outgoing_header(
    &mut self,
    host_tick: Option<u16>,
    last_received_tick: u16,
    packet_type: PacketType,
    payload: &[u8]
) -> Box<[u8]>

Given a packet payload, start tracking the packet via it’s index, attach the appropriate header, and return the packet’s resulting underlying bytes

pub fn get_next_packet_index(&self) -> SequenceNumber

Get the next outgoing packet’s index

pub fn send_message<R: ReplicateSafe<P>>(
    &mut self,
    message: &R,
    guaranteed_delivery: bool
)

Queue up a message to be sent to the remote host

pub fn has_outgoing_messages(&self) -> bool

Returns whether there are messages to be sent to the remote host

pub fn pop_outgoing_message(&mut self, next_packet_index: u16) -> Option<P>

Pop the next outgoing message from the queue

pub fn unpop_outgoing_message(&mut self, next_packet_index: u16, message: P)

If for some reason the next outgoing message could not be written into a message and sent, place it back into the front of the queue

pub fn process_message_data(
    &mut self,
    reader: &mut PacketReader<'_>,
    manifest: &Manifest<P>,
    packet_index: u16
)

Given an incoming packet which has been identified as an message, send the data to the MessageManager for processing

pub fn get_incoming_message(&mut self) -> Option<P>

Get the most recent message that has been received from a remote host

pub fn get_address(&self) -> SocketAddr

Get the address of the remote host

pub fn get_last_received_tick(&self) -> u16

Get the latest received tick from the remote host