Struct stdout_channel::MockStdout

pub struct MockStdout<T>(_);

Implementations

impl<T> MockStdout<T>

pub fn new() -> Self

Methods from Deref<Target = Mutex<Vec<T>>>

pub async fn lock(&'_ self) -> MutexGuard<'_, T>

Locks this mutex, causing the current task to yield until the lock has been acquired. When the lock has been acquired, function returns a MutexGuard.

Cancel safety

This method uses a queue to fairly distribute locks in the order they were requested. Cancelling a call to lock makes you lose your place in the queue.

Examples

use tokio::sync::Mutex;

#[tokio::main]
async fn main() {
    let mutex = Mutex::new(1);

    let mut n = mutex.lock().await;
    *n = 2;
}

pub fn blocking_lock(&self) -> MutexGuard<'_, T>

Blocking lock this mutex. When the lock has been acquired, function returns a MutexGuard.

This method is intended for use cases where you need to use this mutex in asynchronous code as well as in synchronous code.

Examples

use std::sync::Arc;
use tokio::sync::Mutex;

#[tokio::main]
async fn main() {
    let mutex =  Arc::new(Mutex::new(1));

    let mutex1 = Arc::clone(&mutex);
    let sync_code = tokio::task::spawn_blocking(move || {
        let mut n = mutex1.blocking_lock();
        *n = 2;
    });

    sync_code.await.unwrap();

    let n = mutex.lock().await;
    assert_eq!(*n, 2);
}

pub async fn lock_owned(self: Arc<Mutex<T>>) -> OwnedMutexGuard<T>

Locks this mutex, causing the current task to yield until the lock has been acquired. When the lock has been acquired, this returns an OwnedMutexGuard.

This method is identical to Mutex::lock, except that the returned guard references the Mutex with an Arc rather than by borrowing it. Therefore, the Mutex must be wrapped in an Arc to call this method, and the guard will live for the 'static lifetime, as it keeps the Mutex alive by holding an Arc.

Cancel safety

This method uses a queue to fairly distribute locks in the order they were requested. Cancelling a call to lock_owned makes you lose your place in the queue.

Examples

use tokio::sync::Mutex;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let mutex = Arc::new(Mutex::new(1));

    let mut n = mutex.clone().lock_owned().await;
    *n = 2;
}

pub fn try_lock(&self) -> Result<MutexGuard<'_, T>, TryLockError>

Attempts to acquire the lock, and returns TryLockError if the lock is currently held somewhere else.

Examples

use tokio::sync::Mutex;

let mutex = Mutex::new(1);

let n = mutex.try_lock()?;
assert_eq!(*n, 1);

pub fn try_lock_owned(
    self: Arc<Mutex<T>>
) -> Result<OwnedMutexGuard<T>, TryLockError>

Attempts to acquire the lock, and returns TryLockError if the lock is currently held somewhere else.

This method is identical to Mutex::try_lock, except that the returned guard references the Mutex with an Arc rather than by borrowing it. Therefore, the Mutex must be wrapped in an Arc to call this method, and the guard will live for the 'static lifetime, as it keeps the Mutex alive by holding an Arc.

Examples

use tokio::sync::Mutex;
use std::sync::Arc;

let mutex = Arc::new(Mutex::new(1));

let n = mutex.clone().try_lock_owned()?;
assert_eq!(*n, 1);

Trait Implementations

impl<T: Clone> Clone for MockStdout<T>

fn clone(&self) -> MockStdout<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Default for MockStdout<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for MockStdout<T>

type Target = Mutex<Vec<T>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.