Type Alias types::bool

pub type bool = RedisGeneric<bool>;

Aliased Type

struct bool { /* private fields */ }

Implementations

impl<T> RedisGeneric<T>where T: Display + Serialize + DeserializeOwned,

pub fn new(field_name: &str, client: Client) -> RedisGeneric<T>

The new method creates a new instance of the type. It does not load or store any value in Redis. It only creates the instance.

Example

use types::i32;

let client = redis::Client::open("redis://localhost:6379").unwrap();
let mut i32 = i32::new("test_add", client.clone());
i32.store(1);
let i32 = i32 + i32::with_value(2, "test_add2", client);
assert_eq!(i32, 3);

pub fn with_value(value: T, field_name: &str, client: Client) -> RedisGeneric<T>

The with_value method creates a new instance of the type. If a value is already stored in Redis, it will be overwritten.

Examples found in repository

examples/2services.rs (line 11)

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");
    });
}

pub fn with_load(field_name: &str, client: Client) -> RedisGeneric<T>

The with_value_load method creates a new instance of the type. It loads the value from Redis. If there is no value stored in Redis, it stores a None in cache.

Examples found in repository

examples/2services.rs (line 22)

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");
    });
}

pub fn with_value_default( value: T, field_name: &str, client: Client ) -> RedisGeneric<T>

The with_value_default method creates a new instance of the type. If the value is not already stored in Redis, it will be stored. If the value is already stored in Redis, it will be loaded and your given value will be ignored.

pub fn store(&mut self, value: T)

The set method sets the value of the type.

Examples found in repository

examples/2services.rs (line 15)

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");
    });
}

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

The get method returns a reference to the value stored in the type. Loads it from the redis directly.

Example

use types::i32;

let client = redis::Client::open("redis://localhost:6379").unwrap();
let mut i32 = i32::with_value(1, "test_add", client.clone());
i32 = i32 + i32::with_value(2, "test_add2", client);
assert_eq!(i32.acquire(), &3);

Examples found in repository

examples/2services.rs (line 26)

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");
    });
}

pub fn into_inner(self) -> T

The into_inner method returns the inner value of the type. This method consumes the type and drops everything.

Example

use types::i32;

let client = redis::Client::open("redis://localhost:6379").unwrap();
let i32 = i32::with_value(3, "test_add", client.clone());
let i32_inner = i32.into_inner();
assert_eq!(i32_inner, 3);

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<T> Add<RedisGeneric<T>> for RedisGeneric<T>where T: Add<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the + operator.

fn add(self, rhs: RedisGeneric<T>) -> Self::Output

Performs the + operation.

impl<T> Add<T> for RedisGeneric<T>where T: Add<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T> AddAssign<RedisGeneric<T>> for RedisGeneric<T>where T: AddAssign + Display + Serialize + DeserializeOwned,

fn add_assign(&mut self, rhs: RedisGeneric<T>)

Performs the += operation.

impl<T> AddAssign<T> for RedisGeneric<T>where T: AddAssign + Display + Serialize + DeserializeOwned,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T> BitAnd<RedisGeneric<T>> for RedisGeneric<T>where T: BitAnd<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: RedisGeneric<T>) -> Self::Output

Performs the & operation.

impl<T> BitAnd<T> for RedisGeneric<T>where T: BitAnd<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<T> BitOr<RedisGeneric<T>> for RedisGeneric<T>where T: BitOr<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: RedisGeneric<T>) -> Self::Output

Performs the | operation.

impl<T> BitOr<T> for RedisGeneric<T>where T: BitOr<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<T> BitXor<RedisGeneric<T>> for RedisGeneric<T>where T: BitXor<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: RedisGeneric<T>) -> Self::Output

Performs the ^ operation.

impl<T> BitXor<T> for RedisGeneric<T>where T: BitXor<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<T: Debug> Debug for RedisGeneric<T>

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

Formats the value using the given formatter.

impl<T> Deref for RedisGeneric<T>where T: Display + Serialize + DeserializeOwned,

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> Div<RedisGeneric<T>> for RedisGeneric<T>where T: Div<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the / operator.

fn div(self, rhs: RedisGeneric<T>) -> Self::Output

Performs the / operation.

impl<T> Div<T> for RedisGeneric<T>where T: Div<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T> Mul<RedisGeneric<T>> for RedisGeneric<T>where T: Mul<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the * operator.

fn mul(self, rhs: RedisGeneric<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for RedisGeneric<T>where T: Mul<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: PartialEq> PartialEq<RedisGeneric<T>> for RedisGeneric<T>

fn eq(&self, other: &RedisGeneric<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialEq> PartialEq<T> for RedisGeneric<T>

fn eq(&self, other: &T) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Sub<RedisGeneric<T>> for RedisGeneric<T>where T: Sub<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the - operator.

fn sub(self, rhs: RedisGeneric<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<T> for RedisGeneric<T>where T: Sub<Output = T> + Display + Serialize + DeserializeOwned,

type Output = RedisGeneric<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T> SubAssign<RedisGeneric<T>> for RedisGeneric<T>where T: SubAssign + Display + Serialize + DeserializeOwned,

fn sub_assign(&mut self, rhs: RedisGeneric<T>)

Performs the -= operation.

impl<T> SubAssign<T> for RedisGeneric<T>where T: SubAssign + Display + Serialize + DeserializeOwned,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.