Struct RwLockReadGuard 

pub struct RwLockReadGuard<'a, T> { /* private fields */ }

Implementations

impl<'a, T> RwLockReadGuard<'a, T>

where T: Serialize + DeserializeOwned,

pub fn acquire(&mut self) -> &T

Loads the value from Redis. This function blocks until the value is loaded. Shadows the load operation of the guarded value.

Methods from Deref<Target = Generic<T>>

pub fn cached(&self) -> Option<&T>

The get method returns a reference to the value stored in the type.

Examples found in repository

examples/2services.rs (line 12)

fn main() {
    thread::scope(|s| {
        let client = redis::Client::open("redis://localhost:6379").unwrap();
        let client2 = client.clone();

        let t1 = s.spawn(move || {
            let mut string = String::with_value("Hello".to_string(), "test", client);
            println!("Thread1: {}", string.cached().unwrap());
            assert_eq!(string, "Hello");
            sleep(std::time::Duration::from_secs(1));
            string.store("World".to_string());
            println!("Thread1: {}", string.cached().unwrap());
            assert_eq!(string, "World");
        });

        let t2 = s.spawn(move || {
            sleep(std::time::Duration::from_micros(100));
            let mut string = String::with_load("test", client2);
            println!("Thread2: {}", string.cached().unwrap());
            assert_eq!(string, "Hello");
            sleep(std::time::Duration::from_secs(2));
            string.acquire();
            println!("Thread2: {}", string.cached().unwrap());
            assert_eq!(string, "World");
        });
        t1.join().expect("Failed to join thread1");
        t2.join().expect("Failed to join thread2");
    });
}

Trait Implementations

impl<'a, T> Deref for RwLockReadGuard<'a, T>

type Target = Generic<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> Drop for RwLockReadGuard<'_, T>

fn drop(&mut self)

Executes the destructor for this type.