Trait AsyncResolve 

pub trait AsyncResolve: Resolvable {
    type Future: Future<Output = Self::To> + Send;

    // Required method
    fn res_async(self) -> Self::Future;

    // Provided method
    fn res(self) -> Self::Future
       where Self: Sized { ... }
}

Required Associated Types

type Future: Future<Output = Self::To> + Send

Required Methods

fn res_async(self) -> Self::Future

Provided Methods

fn res(self) -> Self::Future

where Self: Sized,

Implementations on Foreign Types

impl AsyncResolve for KeyExprUndeclaration<'_>

type Future = Ready<<KeyExprUndeclaration<'_> as Resolvable>::To>

fn res_async(self) -> <KeyExprUndeclaration<'_> as AsyncResolve>::Future

impl AsyncResolve for Publication<'_>

type Future = Ready<<Publication<'_> as Resolvable>::To>

fn res_async(self) -> <Publication<'_> as AsyncResolve>::Future

impl AsyncResolve for PublisherUndeclaration<'_>

type Future = Ready<<PublisherUndeclaration<'_> as Resolvable>::To>

fn res_async(self) -> <PublisherUndeclaration<'_> as AsyncResolve>::Future

impl AsyncResolve for PutBuilder<'_, '_>

type Future = Ready<<PutBuilder<'_, '_> as Resolvable>::To>

fn res_async(self) -> <PutBuilder<'_, '_> as AsyncResolve>::Future

impl AsyncResolve for SubscriberUndeclaration<'_>

type Future = Ready<<SubscriberUndeclaration<'_> as Resolvable>::To>

fn res_async(self) -> <SubscriberUndeclaration<'_> as AsyncResolve>::Future

impl<'a> AsyncResolve for PeersZidBuilder<'a>

type Future = Ready<<PeersZidBuilder<'a> as Resolvable>::To>

fn res_async(self) -> <PeersZidBuilder<'a> as AsyncResolve>::Future

impl<'a> AsyncResolve for RoutersZidBuilder<'a>

type Future = Ready<<RoutersZidBuilder<'a> as Resolvable>::To>

fn res_async(self) -> <RoutersZidBuilder<'a> as AsyncResolve>::Future

impl<'a> AsyncResolve for ZidBuilder<'a>

type Future = Ready<<ZidBuilder<'a> as Resolvable>::To>

fn res_async(self) -> <ZidBuilder<'a> as AsyncResolve>::Future

impl<'a> AsyncResolve for QueryableUndeclaration<'a>

type Future = Ready<<QueryableUndeclaration<'a> as Resolvable>::To>

fn res_async(self) -> <QueryableUndeclaration<'a> as AsyncResolve>::Future

impl<'a> AsyncResolve for ReplyBuilder<'a>

type Future = Ready<<ReplyBuilder<'a> as Resolvable>::To>

fn res_async(self) -> <ReplyBuilder<'a> as AsyncResolve>::Future

impl<'a, 'b> AsyncResolve for PublisherBuilder<'a, 'b>

type Future = Ready<<PublisherBuilder<'a, 'b> as Resolvable>::To>

fn res_async(self) -> <PublisherBuilder<'a, 'b> as AsyncResolve>::Future

impl<'a, Handler> AsyncResolve for QueryableBuilder<'a, '_, Handler>

where Handler: IntoCallbackReceiverPair<'static, Query> + Send, <Handler as IntoCallbackReceiverPair<'static, Query>>::Receiver: Send,

type Future = Ready<<QueryableBuilder<'a, '_, Handler> as Resolvable>::To>

fn res_async( self, ) -> <QueryableBuilder<'a, '_, Handler> as AsyncResolve>::Future

impl<'a, Handler> AsyncResolve for SubscriberBuilder<'a, '_, PullMode, Handler>

where Handler: IntoCallbackReceiverPair<'static, Sample> + Send, <Handler as IntoCallbackReceiverPair<'static, Sample>>::Receiver: Send,

type Future = Ready<<SubscriberBuilder<'a, '_, PullMode, Handler> as Resolvable>::To>

fn res_async( self, ) -> <SubscriberBuilder<'a, '_, PullMode, Handler> as AsyncResolve>::Future

impl<'a, Handler> AsyncResolve for SubscriberBuilder<'a, '_, PushMode, Handler>

where Handler: IntoCallbackReceiverPair<'static, Sample> + Send, <Handler as IntoCallbackReceiverPair<'static, Sample>>::Receiver: Send,

type Future = Ready<<SubscriberBuilder<'a, '_, PushMode, Handler> as Resolvable>::To>

fn res_async( self, ) -> <SubscriberBuilder<'a, '_, PushMode, Handler> as AsyncResolve>::Future

impl<Handler> AsyncResolve for GetBuilder<'_, '_, Handler>

where Handler: IntoCallbackReceiverPair<'static, Reply> + Send, <Handler as IntoCallbackReceiverPair<'static, Reply>>::Receiver: Send,

type Future = Ready<<GetBuilder<'_, '_, Handler> as Resolvable>::To>

fn res_async(self) -> <GetBuilder<'_, '_, Handler> as AsyncResolve>::Future

impl<Handler> AsyncResolve for ScoutBuilder<Handler>

where Handler: IntoCallbackReceiverPair<'static, Hello> + Send, <Handler as IntoCallbackReceiverPair<'static, Hello>>::Receiver: Send,

type Future = Ready<<ScoutBuilder<Handler> as Resolvable>::To>

fn res_async(self) -> <ScoutBuilder<Handler> as AsyncResolve>::Future

impl<TryIntoConfig> AsyncResolve for OpenBuilder<TryIntoConfig>

where TryIntoConfig: TryInto<Config> + Send + 'static, <TryIntoConfig as TryInto<Config>>::Error: Debug,

type Future = Ready<<OpenBuilder<TryIntoConfig> as Resolvable>::To>

fn res_async(self) -> <OpenBuilder<TryIntoConfig> as AsyncResolve>::Future

Implementors

impl<C, To> AsyncResolve for ResolveClosure<C, To>

where To: Send, C: FnOnce() -> To + Send,

type Future = Ready<<ResolveClosure<C, To> as Resolvable>::To>

impl<F, To> AsyncResolve for ResolveFuture<F, To>

where To: Send, F: Future<Output = To> + Send,

type Future = F