redis_event/cmd/
lists.rs

1/*!
2Lists相关的命令定义、解析
3
4所有涉及到的命令参考[Redis Command Reference]
5
6[Redis Command Reference]: https://redis.io/commands#list
7*/
8
9use std::slice::Iter;
10
11use crate::cmd::lists::POSITION::{AFTER, BEFORE};
12
13#[derive(Debug)]
14pub struct BRPOPLPUSH<'a> {
15    pub source: &'a [u8],
16    pub destination: &'a [u8],
17    pub timeout: &'a [u8],
18}
19
20pub(crate) fn parse_brpoplpush(mut iter: Iter<Vec<u8>>) -> BRPOPLPUSH {
21    let source = iter.next().unwrap();
22    let destination = iter.next().unwrap();
23    let timeout = iter.next().unwrap();
24    BRPOPLPUSH {
25        source,
26        destination,
27        timeout,
28    }
29}
30
31#[derive(Debug)]
32pub struct LINSERT<'a> {
33    pub key: &'a [u8],
34    pub position: POSITION,
35    pub pivot: &'a [u8],
36    pub element: &'a [u8],
37}
38
39#[derive(Debug)]
40pub enum POSITION {
41    BEFORE,
42    AFTER,
43}
44
45pub(crate) fn parse_linsert(mut iter: Iter<Vec<u8>>) -> LINSERT {
46    let key = iter.next().unwrap();
47    let next_arg = iter.next().unwrap();
48    let position;
49    let arg_upper = String::from_utf8_lossy(next_arg).to_uppercase();
50    if &arg_upper == "BEFORE" {
51        position = BEFORE;
52    } else {
53        position = AFTER;
54    }
55    let pivot = iter.next().unwrap();
56    let element = iter.next().unwrap();
57    LINSERT {
58        key,
59        position,
60        pivot,
61        element,
62    }
63}
64
65#[derive(Debug)]
66pub struct LPOP<'a> {
67    pub key: &'a [u8],
68}
69
70pub(crate) fn parse_lpop(mut iter: Iter<Vec<u8>>) -> LPOP {
71    let key = iter.next().unwrap();
72    LPOP { key }
73}
74
75#[derive(Debug)]
76pub struct LPUSH<'a> {
77    pub key: &'a [u8],
78    pub elements: Vec<&'a [u8]>,
79}
80
81pub(crate) fn parse_lpush(mut iter: Iter<Vec<u8>>) -> LPUSH {
82    let key = iter.next().unwrap();
83    let mut elements = Vec::new();
84    while let Some(ele) = iter.next() {
85        elements.push(ele.as_slice());
86    }
87    LPUSH { key, elements }
88}
89
90#[derive(Debug)]
91pub struct LPUSHX<'a> {
92    pub key: &'a [u8],
93    pub elements: Vec<&'a [u8]>,
94}
95
96pub(crate) fn parse_lpushx(mut iter: Iter<Vec<u8>>) -> LPUSHX {
97    let key = iter.next().unwrap();
98    let mut elements = Vec::new();
99    while let Some(ele) = iter.next() {
100        elements.push(ele.as_slice());
101    }
102    LPUSHX { key, elements }
103}
104
105#[derive(Debug)]
106pub struct LREM<'a> {
107    pub key: &'a [u8],
108    pub count: &'a [u8],
109    pub element: &'a [u8],
110}
111
112pub(crate) fn parse_lrem(mut iter: Iter<Vec<u8>>) -> LREM {
113    let key = iter.next().unwrap();
114    let count = iter.next().unwrap();
115    let element = iter.next().unwrap();
116    LREM { key, count, element }
117}
118
119#[derive(Debug)]
120pub struct LSET<'a> {
121    pub key: &'a [u8],
122    pub index: &'a [u8],
123    pub element: &'a [u8],
124}
125
126pub(crate) fn parse_lset(mut iter: Iter<Vec<u8>>) -> LSET {
127    let key = iter.next().unwrap();
128    let index = iter.next().unwrap();
129    let element = iter.next().unwrap();
130    LSET { key, index, element }
131}
132
133#[derive(Debug)]
134pub struct LTRIM<'a> {
135    pub key: &'a [u8],
136    pub start: &'a [u8],
137    pub stop: &'a [u8],
138}
139
140pub(crate) fn parse_ltrim(mut iter: Iter<Vec<u8>>) -> LTRIM {
141    let key = iter.next().unwrap();
142    let start = iter.next().unwrap();
143    let stop = iter.next().unwrap();
144    LTRIM { key, start, stop }
145}
146
147#[derive(Debug)]
148pub struct RPOP<'a> {
149    pub key: &'a [u8],
150}
151
152pub(crate) fn parse_rpop(mut iter: Iter<Vec<u8>>) -> RPOP {
153    let key = iter.next().unwrap();
154    RPOP { key }
155}
156
157#[derive(Debug)]
158pub struct RPOPLPUSH<'a> {
159    pub source: &'a [u8],
160    pub destination: &'a [u8],
161}
162
163pub(crate) fn parse_rpoplpush(mut iter: Iter<Vec<u8>>) -> RPOPLPUSH {
164    let source = iter.next().unwrap();
165    let destination = iter.next().unwrap();
166    RPOPLPUSH { source, destination }
167}
168
169#[derive(Debug)]
170pub struct RPUSH<'a> {
171    pub key: &'a [u8],
172    pub elements: Vec<&'a [u8]>,
173}
174
175pub(crate) fn parse_rpush(mut iter: Iter<Vec<u8>>) -> RPUSH {
176    let key = iter.next().unwrap();
177    let mut elements = Vec::new();
178    while let Some(ele) = iter.next() {
179        elements.push(ele.as_slice());
180    }
181    RPUSH { key, elements }
182}
183
184#[derive(Debug)]
185pub struct RPUSHX<'a> {
186    pub key: &'a [u8],
187    pub elements: Vec<&'a [u8]>,
188}
189
190pub(crate) fn parse_rpushx(mut iter: Iter<Vec<u8>>) -> RPUSHX {
191    let key = iter.next().unwrap();
192    let mut elements = Vec::new();
193    while let Some(ele) = iter.next() {
194        elements.push(ele.as_slice());
195    }
196    RPUSHX { key, elements }
197}
redis_event/cmd/lists.rs

redis_event/cmd/
lists.rs
