Enum ContextCell 

pub enum ContextCell<C> {
    Present(C),
    Missing,
}

A wrapper around context that allows it to be taken and returned without requiring all interactions to unwrap (as with Option<C>).

Variants

Present(C)

A context available for use.

Missing

The context has been taken elsewhere.

Implementations

impl<C> Cell<C>

pub fn new(context: C) -> Self

Create a new slot containing context.

pub fn take(&mut self) -> C

Remove the context from the slot, panicking if it is missing.

pub fn restore(&mut self, context: C)

Return a context to the slot, panicking if one is already present.

pub fn into(self) -> C

Consume the slot, returning the context and panicking if it is missing.

Trait Implementations

impl<C> AsMut<C> for Cell<C>

fn as_mut(&mut self) -> &mut C

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C> AsRef<C> for Cell<C>

fn as_ref(&self) -> &C

Converts this type into a shared reference of the (usually inferred) input type.

impl<C> Clock for Cell<C>

where C: Clock,

fn current(&self) -> SystemTime

Returns the current time.

fn sleep(&self, duration: Duration) -> impl Future<Output = ()> + Send + 'static

Sleep for the given duration.

fn sleep_until( &self, deadline: SystemTime, ) -> impl Future<Output = ()> + Send + 'static

Sleep until the given deadline.

fn timeout<F, T>( &self, duration: Duration, future: F, ) -> impl Future<Output = Result<T, Error>> + Send + '_

where F: Future<Output = T> + Send + 'static, T: Send + 'static,

Await a future with a timeout, returning Error::Timeout if it expires.

impl<C> Clock for Cell<C>

where C: GClock,

type Instant = <C as Clock>::Instant

A measurement of a monotonically increasing clock.

fn now(&self) -> Self::Instant

Returns a measurement of the clock.

impl<C: Clone> Clone for Cell<C>

fn clone(&self) -> Cell<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug> Debug for Cell<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C> Metrics for Cell<C>

where C: Metrics,

fn label(&self) -> String

Get the current label of the context.

fn with_label(&self, label: &str) -> Self

Create a new instance of Metrics with the given label appended to the end of the current Metrics label.

fn register<N: Into<String>, H: Into<String>>( &self, name: N, help: H, metric: impl Metric, )

Register a metric with the runtime.

fn encode(&self) -> String

Encode all metrics into a buffer.

fn scoped_label(&self, label: &str) -> String

Prefix the given label with the current context’s label.

impl<C> Network for Cell<C>

where C: Network,

type Listener = <C as Network>::Listener

The type of Listener that’s returned when binding to a socket. Accepting a connection returns a Sink and Stream which are defined by the Listener and used to send and receive data over the connection.

fn bind( &self, socket: SocketAddr, ) -> impl Future<Output = Result<Self::Listener, Error>> + Send

Bind to the given socket address.

fn dial( &self, socket: SocketAddr, ) -> impl Future<Output = Result<(SinkOf<Self>, StreamOf<Self>), Error>> + Send

Dial the given socket address.

impl<C> ReasonablyRealtime for Cell<C>

where C: ReasonablyRealtime,

fn reference_point(&self) -> Self::Instant

Returns a reference point at the start of an operation.

impl<C> RngCore for Cell<C>

where C: RngCore,

fn next_u32(&mut self) -> u32

Return the next random u32.

fn next_u64(&mut self) -> u64

Return the next random u64.

fn fill_bytes(&mut self, dest: &mut [u8])

Fill dest with random data.

fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>

Fill dest entirely with random data.

impl<C> Spawner for Cell<C>

where C: Spawner,

fn dedicated(self) -> Self

Return a Spawner that runs tasks on a dedicated thread when the runtime supports it.

fn shared(self, blocking: bool) -> Self

Return a Spawner that schedules tasks onto the runtime’s shared executor.

fn instrumented(self) -> Self

Return a Spawner that instruments the next spawned task with the label of the spawning context.

fn spawn<F, Fut, T>(self, f: F) -> Handle<T>

where F: FnOnce(Self) -> Fut + Send + 'static, Fut: Future<Output = T> + Send + 'static, T: Send + 'static,

Spawn a task with the current context.

fn stop( self, value: i32, timeout: Option<Duration>, ) -> impl Future<Output = Result<(), Error>> + Send

Signals the runtime to stop execution and waits for all outstanding tasks to perform any required cleanup and exit.

fn stopped(&self) -> Signal

Returns an instance of a signal::Signal that resolves when Spawner::stop is called by any task.

impl<C> Storage for Cell<C>

where C: Storage,

type Blob = <C as Storage>::Blob

The readable/writeable storage buffer that can be opened by this Storage.

fn open( &self, partition: &str, name: &[u8], ) -> impl Future<Output = Result<(Self::Blob, u64), Error>> + Send

Open an existing blob in a given partition or create a new one, returning the blob and its length.

fn remove( &self, partition: &str, name: Option<&[u8]>, ) -> impl Future<Output = Result<(), Error>> + Send

Remove a blob from a given partition.

fn scan( &self, partition: &str, ) -> impl Future<Output = Result<Vec<Vec<u8>>, Error>> + Send

Return all blobs in a given partition.

impl<C> CryptoRng for Cell<C>

where C: CryptoRng,