Struct amethyst_network::NetConnection

pub struct NetConnection<E: 'static> {
    pub target_addr: SocketAddr,
    pub state: ConnectionState,
    // some fields omitted
}

A remote connection to some endpoint.

This type is a Component, and it is used by systems too:

• Queue received data into this type
• Read the queued data from the user for transmission.

Remark

Note that this type does not perform any reading or writing, this is done only within systems. This type acts as a container for to send and received data.

Fields

target_addr: SocketAddr

The target remote socket address who is listening for incoming packets.

state: ConnectionState

The state of the connection.

Methods

impl<E: Send + Sync + 'static> NetConnection<E>

pub fn new(target_addr: SocketAddr) -> Self

Construct a new NetConnection.

• SocketAddr: the remote endpoint, from here the data will be send to and received from.

pub fn queue_iter<I>(&mut self, iter: I) where
    I: IntoIterator<Item = NetEvent<E>>,
    I::IntoIter: ExactSizeIterator, 

Queues the given event iterator of events for transmission. This function writes the passed event iterator to a buffer which can be read by a System. It is the job of the System to send those events to the remote client.

pub fn queue_vec(&mut self, events: &mut Vec<NetEvent<E>>)

Queues the given vector of events for transmission. This function writes the passed event vector to a buffer which can be read by a System. It is the job of the System to send those events to the remote client.

pub fn queue(&mut self, event: NetEvent<E>)

Queues a single event for transmission. This function writes the passed event to a buffer which can be read by a System. It is the job of the System to send this event to the remote client.

pub fn received_events(
    &self,
    reader_id: &mut ReaderId<NetEvent<E>>
) -> EventIterator<NetEvent<E>>

Returns an iterator over the received events.

• reader_id: the reader id of the registered reader.

Remark

• To be able to read events, a reader id is required. This is required for the underlying ringbuffer. The reader id stores information of where in the ringbuffer the reader has read from earlier. Please checkout register_reader which will return a ReaderId that allows you to read the received events.

pub fn register_reader(&mut self) -> ReaderId<NetEvent<E>>

Returns a ReaderId that can be used to read from the received events.

Remark

• To be able to read events, a reader id is required. This is because otherwise the channel wouldn't know where in the ringbuffer the reader has read to earlier. This information is stored in the reader id.

Trait Implementations

impl<E: PartialEq> Eq for NetConnection<E>

impl<E> PartialEq<NetConnection<E>> for NetConnection<E>

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<E: 'static> Serialize for NetConnection<E>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<E: Send + Sync + 'static> Component for NetConnection<E>

type Storage = VecStorage<Self>

Associated storage type for this component.