Struct Generic 

pub struct Generic<T> { /* private fields */ }

The generic type is used to implement the common methods for all types.

The generic type is not meant to be used directly. Instead use one of the aliases.

Mostly you will interact with the methods Generic::store, Generic::acquire and Generic::into_inner.

Implementations

impl<T> Generic<T>

where T: Serialize + DeserializeOwned,

pub fn new(field_name: &str, client: Client) -> Generic<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 dtypes::redis::types::Di32 as 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) -> Generic<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) -> Generic<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, ) -> Generic<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 store 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 acquire method returns a reference to the value stored in the type. Loads it from the redis directly.

Example

use dtypes::redis::types::Di32 as 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 dtypes::redis::types::Di32 as 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 Add<&Generic<String>> for TString

type Output = Generic<String>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<T> for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AddAssign<T> for Generic<T>

where T: AddAssign + Display + Serialize + DeserializeOwned,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T> AddAssign for Generic<T>

where T: AddAssign + Display + Serialize + DeserializeOwned,

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

Performs the += operation.

impl<T> BitAnd<T> for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T> BitAnd for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T> BitOr<T> for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T> BitOr for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T> BitXor<T> for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T> BitXor for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T: Debug> Debug for Generic<T>

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

Formats the value using the given formatter.

impl<T> Deref for Generic<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<T> for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Mul<T> for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: PartialEq> PartialEq<T> for Generic<T>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq for Generic<T>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Sub<T> for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub for Generic<T>

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

type Output = Generic<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> SubAssign<T> for Generic<T>

where T: SubAssign + Display + Serialize + DeserializeOwned,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T> SubAssign for Generic<T>

where T: SubAssign + Display + Serialize + DeserializeOwned,

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

Performs the -= operation.