redisclient 0.1.2

Redis client for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

mod maps;
mod numbers;
mod sequences;
mod sets;
mod strings;

use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
use std::hash::Hash;

use crate::client::ListBeforeOrAfter;
use crate::connection::{Reply, SingleStrings};
use crate::error::ErrorKind::{ResponseError, TypeError};
use crate::error::RedisError;
use crate::implement_deserialization_for_maps;
use crate::implement_deserialization_for_numbers;
use crate::implement_deserialization_for_sets;
use crate::implement_deserialization_for_string;
use crate::implement_serialization_for_maps;
use crate::implement_serialization_for_numbers;
use crate::implement_serialization_for_sets;
use crate::implement_serialization_for_string;
use crate::DataType;
use crate::RedisResult;

pub trait RedisSerializationProtocol {
    fn serialization(&self) -> Vec<u8>;
}

pub trait RedisDeserializationProtocol {
    fn deserialization(reply: Reply) -> RedisResult<Self>
    where
        Self: Sized;
}

// ---------------------------------------

implement_deserialization_for_string!(String);
implement_serialization_for_string!(String, &str);

implement_serialization_for_numbers!(u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, usize, isize, f32, f64);
implement_deserialization_for_numbers!(u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, usize, isize, f32, f64);

implement_serialization_for_maps!(HashMap, BTreeMap);
implement_deserialization_for_maps!(HashMap, BTreeMap);

implement_serialization_for_sets!(HashSet, BTreeSet);
implement_deserialization_for_sets!(HashSet); // TODO: BTreeSet, Ord trait

impl RedisDeserializationProtocol for () {
    fn deserialization(reply: Reply) -> RedisResult<Self> {
        match reply {
            Reply::SingleStrings(single) => match single {
                SingleStrings::Okay | SingleStrings::Pong => Ok(()),
                _ => Err(RedisError::custom(ResponseError, "wrong data type")),
            },
            _ => Err(RedisError::custom(TypeError, "miss type")),
        }
    }
}

impl RedisDeserializationProtocol for bool {
    fn deserialization(reply: Reply) -> RedisResult<Self> {
        let v = <usize>::deserialization(reply)?;
        Ok(v != 0)
    }
}

impl RedisDeserializationProtocol for DataType {
    fn deserialization(reply: Reply) -> RedisResult<Self> {
        match reply {
            Reply::SingleStrings(single) => match single {
                SingleStrings::String => Ok(DataType::String),
                SingleStrings::List => Ok(DataType::List),
                SingleStrings::Set => Ok(DataType::Set),
                _ => Err(RedisError::custom(ResponseError, "wrong data type")),
            },
            _ => Err(RedisError::custom(TypeError, "miss type")),
        }
    }
}

macro_rules! implement_serialization_for_sequences {
    ($($t:ty),*) => {
        $(
            impl RedisSerializationProtocol for $t {
                fn serialization(&self) -> Vec<u8> {
                    let length = self.len();
                    let mut buf = Vec::new();
                    buf.extend(b"*1\r\n");
                    buf.extend(format!("${}\r\n", length).as_bytes());
                    buf.extend(self);
                    buf.extend(b"\r\n");
                    buf
                }
            }
        )*
    };
}

implement_serialization_for_sequences!(Vec<u8>);

impl RedisSerializationProtocol for ListBeforeOrAfter {
    fn serialization(&self) -> Vec<u8> {
        match self {
            ListBeforeOrAfter::Before => "BEFORE".serialization(),
            ListBeforeOrAfter::After => "AFTER".serialization(),
        }
    }
}

impl<T> RedisDeserializationProtocol for Vec<T>
where
    T: RedisDeserializationProtocol,
{
    fn deserialization(reply: Reply) -> RedisResult<Self> {
        match reply {
            Reply::Arrays(array) => {
                let mut values = Vec::new();
                for ele in array {
                    values.push(<T>::deserialization(ele)?);
                }
                Ok(values)
            }
            _ => Err(RedisError::custom(TypeError, "miss type")),
        }
    }
}