Enum hardlight::ServerMessage

pub enum ServerMessage {
    RPCResponse {
        id: u8,
        output: Result<Vec<u8>, RpcHandlerError>,
    },
    NewEvent {
        event: Vec<u8>,
    },
    StateChange(Vec<(usize, Vec<u8>)>),
}

Variants

RPCResponse

Fields

id: u8

A unique counter for each RPC call. This is used to match responses to requests. It restricts the number of concurrent operations to 256. Active operations cannot reuse the same ID, therefore IDs of completed requests can be reused.

output: Result<Vec<u8>, RpcHandlerError>

The function’s output serialized with rkyv. The format of this message will differ with each application. The macros handle generating the code for this.

A message from the server with the output of a client’s method call.

NewEvent

Fields

event: Vec<u8>

The event serialized with rkyv. The format of this will differ between applications. The macros handle generating the code for this.

A message from the server with a new event.

StateChange(Vec<(usize, Vec<u8>)>)

The server updates the connection state.

Trait Implementations

impl Archive for ServerMessagewhere u8: Archive, Result<Vec<u8>, RpcHandlerError>: Archive, Vec<u8>: Archive, Vec<(usize, Vec<u8>)>: Archive,

type Archived = ArchivedServerMessage

The archived representation of this type.

type Resolver = ServerMessageResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <Self as Archive>::Resolver, out: *mut <Self as Archive>::Archived )

Creates the archived version of this value at the given position and writes it to the given output.

impl<__D: Fallible + ?Sized> Deserialize<ServerMessage, __D> for Archived<ServerMessage>where u8: Archive, Archived<u8>: Deserialize<u8, __D>, Result<Vec<u8>, RpcHandlerError>: Archive, Archived<Result<Vec<u8>, RpcHandlerError>>: Deserialize<Result<Vec<u8>, RpcHandlerError>, __D>, Vec<u8>: Archive, Archived<Vec<u8>>: Deserialize<Vec<u8>, __D>, Vec<(usize, Vec<u8>)>: Archive, Archived<Vec<(usize, Vec<u8>)>>: Deserialize<Vec<(usize, Vec<u8>)>, __D>,

fn deserialize( &self, deserializer: &mut __D ) -> Result<ServerMessage, __D::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for ServerMessagewhere u8: Serialize<__S>, Result<Vec<u8>, RpcHandlerError>: Serialize<__S>, Vec<u8>: Serialize<__S>, Vec<(usize, Vec<u8>)>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S ) -> Result<<Self as Archive>::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.