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

/*!
Sets相关的命令定义、解析

所有涉及到的命令参考[Redis Command Reference]

[Redis Command Reference]: https://redis.io/commands#set
*/

use std::slice::Iter;

#[derive(Debug)]
pub struct SINTERSTORE<'a> {
    pub destination: &'a [u8],
    pub keys: Vec<&'a [u8]>,
}

pub(crate) fn parse_sinterstore(mut iter: Iter<Vec<u8>>) -> SINTERSTORE {
    let destination = iter.next().unwrap();
    let mut keys = Vec::new();
    for next_arg in iter {
        keys.push(next_arg.as_slice());
    }
    SINTERSTORE { destination, keys }
}

#[derive(Debug)]
pub struct SADD<'a> {
    pub key: &'a [u8],
    pub members: Vec<&'a [u8]>,
}

pub(crate) fn parse_sadd(mut iter: Iter<Vec<u8>>) -> SADD {
    let key = iter.next().unwrap();
    let mut members = Vec::new();
    while let Some(member) = iter.next() {
        members.push(member.as_slice());
    }
    SADD { key, members }
}

#[derive(Debug)]
pub struct SDIFFSTORE<'a> {
    pub destination: &'a [u8],
    pub keys: Vec<&'a [u8]>,
}

pub(crate) fn parse_sdiffstore(mut iter: Iter<Vec<u8>>) -> SDIFFSTORE {
    let destination = iter.next().unwrap();
    let mut keys = Vec::new();
    while let Some(key) = iter.next() {
        keys.push(key.as_slice());
    }
    SDIFFSTORE { destination, keys }
}

#[derive(Debug)]
pub struct SMOVE<'a> {
    pub source: &'a [u8],
    pub destination: &'a [u8],
    pub member: &'a [u8],
}

pub(crate) fn parse_smove(mut iter: Iter<Vec<u8>>) -> SMOVE {
    let source = iter.next().unwrap();
    let destination = iter.next().unwrap();
    let member = iter.next().unwrap();
    SMOVE { source, destination, member }
}

#[derive(Debug)]
pub struct SREM<'a> {
    pub key: &'a [u8],
    pub members: Vec<&'a [u8]>,
}

pub(crate) fn parse_srem(mut iter: Iter<Vec<u8>>) -> SREM {
    let key = iter.next().unwrap();
    let mut members = Vec::new();
    while let Some(member) = iter.next() {
        members.push(member.as_slice());
    }
    SREM { key, members }
}

#[derive(Debug)]
pub struct SUNIONSTORE<'a> {
    pub destination: &'a [u8],
    pub keys: Vec<&'a [u8]>,
}

pub(crate) fn parse_sunionstore(mut iter: Iter<Vec<u8>>) -> SUNIONSTORE {
    let destination = iter.next().unwrap();
    let mut keys = Vec::new();
    for next_arg in iter {
        keys.push(next_arg.as_slice());
    }
    SUNIONSTORE { destination, keys }
}