Struct Session 

pub struct Session {
    pub adapter: Arc<dyn Adapter>,
    pub service: Arc<dyn Service>,
    pub log_error: AtomicBool,
    pub tokio: Option<Box<Handle>>,
    /* private fields */
}

Represents a RPC session.

A session represents a connection endpoint of the adapter, such as a websocket, named pipe, etc.

Fields

adapter: Arc<dyn Adapter>

Adapter object

service: Arc<dyn Service>

Service object

log_error: AtomicBool

Whether to record error log

tokio: Option<Box<Handle>>

Tokio runtime handle

Implementations

impl Session

pub fn from<A: Adapter, S: Service>(adapter: A, service: S) -> Self

Simple wrapper for Session::new()

pub fn new(adapter: Arc<dyn Adapter>, service: Arc<dyn Service>) -> Self

Create a new Session from an adapter and a service

pub fn downcast_adapter<A: Adapter>(&self) -> Option<Arc<A>>

Try downcast the adaptor trait object to its concrete type

pub fn downcast_service<S: Service>(&self) -> Option<Arc<S>>

Try downcast the service trait object to its concrete type

pub fn mapped_service<T: Send + Sync + 'static>(&self) -> Arc<MappedService<T>>

Assert the service is a MappedService

impl Session

pub async fn notify<A: Serialize, M: Serialize>( &self, method: M, args: A, ) -> Result<()>

Do a notify RPC

pub async fn notify_de<'de, A: Deserializer<'de>, M: Deserializer<'de>>( &self, method: M, args: A, ) -> Result<()>

Do a notify RPC, encode args from a Deserializer

pub fn notify_sync<A: Serialize, M: Serialize>( &self, method: M, args: A, ) -> Result<()>

pub async fn request<A: Serialize, M: Serialize, R: FromPacket>( self: &Arc<Self>, method: M, args: A, ) -> Result<R>

Do a request RPC

pub async fn request_recver<A: Serialize, M: Serialize>( self: &Arc<Self>, method: M, args: A, ) -> Result<StreamReceiver>

Do a request RPC, and receive its result as a stream

pub async fn request_de<'de, A: Deserializer<'de>, M: Deserializer<'de>, R: Serializer>( self: &Arc<Self>, method: M, args: A, result: R, ) -> Result<R::Ok>

Do a request RPCd, encode args from a Deserializer

pub async fn request_recver_de<'de, A: Deserializer<'de>, M: Deserializer<'de>>( self: &Arc<Self>, method: M, args: A, ) -> Result<StreamReceiver>

pub fn request_sync<A: Serialize, M: Serialize, R: FromPacket>( self: &Arc<Self>, method: M, args: A, ) -> Result<R>

pub async fn request_packet<A: Serialize, M: Serialize>( self: &Arc<Self>, method: M, args: A, ) -> Result<Packet>

Do a request RPC, return the raw packet rather than deserializing the requested data

pub async fn request_with<A: Serialize, M: Serialize, FUT: Future<Output = ()> + NeedSend, F: FnOnce(Packet) -> FUT + Send + 'static>( &self, method: M, args: A, callback: F, ) -> Result<()>

Do a request RPC with your async callback

pub async fn loop_dispatch(self: &Arc<Self>) -> Result<()>

Repeatly do dispath until the adapter disconnect

pub async fn dispatch(self: &Arc<Self>) -> Result<()>

Receive a packet and dispatch to service to handle it once

pub fn dispatch_sync(self: &Arc<Self>) -> Result<()>

pub async fn try_recv(&self) -> Option<Result<Packet>>

Try to receive a packet

pub fn try_recv_sync(&self) -> Option<Result<Packet>>

pub async fn transfer_packet( self: &Arc<Self>, from: &Self, packet: &Packet, ) -> Result<()>

Transfer a packet from other session to this session

pub async fn response(&self, req_id: u32, args: impl Serialize) -> Result<()>

Response a request manually

pub async fn response_de<'de, A: Deserializer<'de>>( &self, req_id: u32, args: A, ) -> Result<()>

Response a request manually, encode args from a Deserializer

pub fn response_sync(&self, req_id: u32, args: impl Serialize) -> Result<()>

pub async fn response_error( &self, req_id: u32, err: impl AsRef<str>, ) -> Result<()>

Response a request with error message manually

pub async fn stream_packet( &self, req_id: u32, args: impl Serialize, ) -> Result<()>

pub async fn stream_packet_end(&self, req_id: u32) -> Result<()>

pub fn response_error_sync( &self, req_id: u32, err: impl AsRef<str>, ) -> Result<()>

impl Session

pub fn ws_adapter(&self) -> Option<Arc<WsAdapter>>

pub async fn ws_connect<A: ToString + AsRef<str>, S: Service>( address: A, service: S, ) -> Result<Self>

pub async fn ws_accept<A: ToSocketAddrs, S: Service>( address: A, service: S, ) -> Result<Self>