Struct RemoteSession

pub struct RemoteSession { /* private fields */ }

Implementations§

Trait Implementations§

Called once the Actor has been started

Called once the Actor has stopped

Creates a new ActorContext, allowing actor implementations to override specific parts of the ActorContext, before the actor is started.

Called when a supervised actor has stopped

Returns a LocalActorRef<Self> instance of the current actor, automatically casting from the ActorContext’s BoxedActorRef.

Returns the actor’s type name string

Default tags used when creating the actor

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The alignment of pointer.

The type for initializers.

Initializes a with the given initializer. Read more

Dereferences the given pointer. Read more

Mutably dereferences the given pointer. Read more

Drops the object pointed to by the given pointer. Read more

Should always be Self

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Struct RemoteSession Copy item path

Implementations§

impl RemoteSession

pub fn new( id: i64, addr: SocketAddr, stream: TcpStream, remote_server_config: RemoteServerConfigRef, ) -> RemoteSession

impl RemoteSession

pub async fn write(&mut self, message: ClientEvent)

Trait Implementations§

impl Actor for RemoteSession

fn started<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn stopped<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn new_context( &self, system: Option<ActorSystem>, status: ActorStatus, boxed_ref: BoxedActorRef, ) -> ActorContext

fn on_child_stopped<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _id: &'life1 ActorId, _ctx: &'life2 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn actor_ref(&self, ctx: &ActorContext) -> LocalActorRef<Self>where Self: Sized,

fn type_name() -> &'static strwhere Self: Sized,

fn tags(&self, ctx: &ActorContext) -> ActorTags

const DEFAULT_TAGS: ActorTags = { ActorTags::None }

impl Handler<SessionWrite> for RemoteSession

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: SessionWrite, _ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Auto Trait Implementations§

impl Freeze for RemoteSession

impl RefUnwindSafe for RemoteSession

impl Send for RemoteSession

impl Sync for RemoteSession

impl Unpin for RemoteSession

impl UnsafeUnpin for RemoteSession

impl UnwindSafe for RemoteSession

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DTwhere ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DTwhere ST: ?Sized, DT: ?Sized,

impl<T> From<T> for T

fn from(t: T) -> T

impl<A> Handler<Describe> for Awhere A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Describe, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<F, A, R> Handler<Exec<F, A, R>> for Awhere A: Actor, F: FnMut(&mut A) -> R + 'static + Send + Sync, R: 'static + Send + Sync,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Exec<F, A, R>, _ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = R> + Send + 'async_trait>>where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Status> for Awhere A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, _message: Status, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ActorStatus> + Send + 'async_trait>>where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Stop> for Awhere A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, stop: Stop, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Terminated> for Awhere A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Terminated, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Unwatch> for Awhere A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Unwatch, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Watch> for Awhere A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Watch, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<A> IntoActor for Awhere A: Actor,

fn into_actor<'a, 'life0, 'async_trait, I>( self, id: Option<I>, sys: &'life0 ActorSystem, ) -> Pin<Box<dyn Future<Output = Result<LocalActorRef<A>, ActorRefErr>> + Send + 'async_trait>>where 'a: 'async_trait, 'life0: 'async_trait, I: 'async_trait + 'a + IntoActorId + Send, A: 'async_trait,

fn into_anon_actor<'a, 'life0, 'async_trait, I>( self, id: Option<I>, sys: &'life0 ActorSystem, ) -> Pin<Box<dyn Future<Output = Result<LocalActorRef<A>, ActorRefErr>> + Send + 'async_trait>>where 'a: 'async_trait, 'life0: 'async_trait, I: 'async_trait + 'a + IntoActorId + Send, A: 'async_trait,

impl<A> IntoChild for Awhere A: Actor,

fn into_child<'life0, 'async_trait>( self, id: Option<Arc<str>>, ctx: &'life0 mut ActorContext, ) -> Pin<Box<dyn Future<Output = Result<LocalActorRef<A>, ActorRefErr>> + Send + 'async_trait>>where 'life0: 'async_trait, A: 'async_trait,

impl<T> Pointable for T

const ALIGN: usize

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Read<Exclusive, BecauseExclusive> for Twhere T: ?Sized,

impl<T> Same for T

type Output = T

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

Struct RemoteSession

fn started<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn stopped<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn on_child_stopped<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _id: &'life1 ActorId, _ctx: &'life2 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn actor_ref(&self, ctx: &ActorContext) -> LocalActorRef<Self>
where Self: Sized,

fn type_name() -> &'static str
where Self: Sized,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: SessionWrite, _ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

impl<A> Handler<Describe> for A
where A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Describe, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<F, A, R> Handler<Exec<F, A, R>> for A
where A: Actor, F: FnMut(&mut A) -> R + 'static + Send + Sync, R: 'static + Send + Sync,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Exec<F, A, R>, _ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = R> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Status> for A
where A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, _message: Status, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ActorStatus> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Stop> for A
where A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, stop: Stop, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Terminated> for A
where A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Terminated, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Unwatch> for A
where A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Unwatch, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<A> Handler<Watch> for A
where A: Actor,

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, message: Watch, ctx: &'life1 mut ActorContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, A: 'async_trait,

impl<T, U> Into<U> for T
where U: From<T>,

impl<A> IntoActor for A
where A: Actor,

fn into_actor<'a, 'life0, 'async_trait, I>( self, id: Option<I>, sys: &'life0 ActorSystem, ) -> Pin<Box<dyn Future<Output = Result<LocalActorRef<A>, ActorRefErr>> + Send + 'async_trait>>
where 'a: 'async_trait, 'life0: 'async_trait, I: 'async_trait + 'a + IntoActorId + Send, A: 'async_trait,

fn into_anon_actor<'a, 'life0, 'async_trait, I>( self, id: Option<I>, sys: &'life0 ActorSystem, ) -> Pin<Box<dyn Future<Output = Result<LocalActorRef<A>, ActorRefErr>> + Send + 'async_trait>>
where 'a: 'async_trait, 'life0: 'async_trait, I: 'async_trait + 'a + IntoActorId + Send, A: 'async_trait,

impl<A> IntoChild for A
where A: Actor,

fn into_child<'life0, 'async_trait>( self, id: Option<Arc<str>>, ctx: &'life0 mut ActorContext, ) -> Pin<Box<dyn Future<Output = Result<LocalActorRef<A>, ActorRefErr>> + Send + 'async_trait>>
where 'life0: 'async_trait, A: 'async_trait,

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,