fred/commands/impls/
sets.rs

1use super::*;
2use crate::{
3  protocol::{command::CommandKind, utils as protocol_utils},
4  types::*,
5  utils,
6};
7use std::convert::TryInto;
8
9pub async fn sadd<C: ClientLike>(client: &C, key: Key, members: MultipleValues) -> Result<Value, Error> {
10  let frame = utils::request_response(client, move || {
11    let members = members.into_multiple_values();
12    let mut args = Vec::with_capacity(1 + members.len());
13    args.push(key.into());
14
15    for member in members.into_iter() {
16      args.push(member);
17    }
18    Ok((CommandKind::Sadd, args))
19  })
20  .await?;
21
22  protocol_utils::frame_to_results(frame)
23}
24
25pub async fn scard<C: ClientLike>(client: &C, key: Key) -> Result<Value, Error> {
26  one_arg_value_cmd(client, CommandKind::Scard, key.into()).await
27}
28
29pub async fn sdiff<C: ClientLike>(client: &C, keys: MultipleKeys) -> Result<Value, Error> {
30  let frame = utils::request_response(client, move || {
31    let mut args = Vec::with_capacity(keys.len());
32
33    for key in keys.inner().into_iter() {
34      args.push(key.into());
35    }
36    Ok((CommandKind::Sdiff, args))
37  })
38  .await?;
39
40  protocol_utils::frame_to_results(frame)
41}
42
43pub async fn sdiffstore<C: ClientLike>(client: &C, dest: Key, keys: MultipleKeys) -> Result<Value, Error> {
44  let frame = utils::request_response(client, move || {
45    let mut args = Vec::with_capacity(1 + keys.len());
46    args.push(dest.into());
47
48    for key in keys.inner().into_iter() {
49      args.push(key.into());
50    }
51    Ok((CommandKind::Sdiffstore, args))
52  })
53  .await?;
54
55  protocol_utils::frame_to_results(frame)
56}
57
58pub async fn sinter<C: ClientLike>(client: &C, keys: MultipleKeys) -> Result<Value, Error> {
59  let frame = utils::request_response(client, move || {
60    let mut args = Vec::with_capacity(keys.len());
61
62    for key in keys.inner().into_iter() {
63      args.push(key.into());
64    }
65    Ok((CommandKind::Sinter, args))
66  })
67  .await?;
68
69  protocol_utils::frame_to_results(frame)
70}
71
72pub async fn sinterstore<C: ClientLike>(client: &C, dest: Key, keys: MultipleKeys) -> Result<Value, Error> {
73  let frame = utils::request_response(client, move || {
74    let mut args = Vec::with_capacity(1 + keys.len());
75    args.push(dest.into());
76
77    for key in keys.inner().into_iter() {
78      args.push(key.into());
79    }
80    Ok((CommandKind::Sinterstore, args))
81  })
82  .await?;
83
84  protocol_utils::frame_to_results(frame)
85}
86
87pub async fn sismember<C: ClientLike>(client: &C, key: Key, member: Value) -> Result<Value, Error> {
88  args_value_cmd(client, CommandKind::Sismember, vec![key.into(), member]).await
89}
90
91pub async fn smismember<C: ClientLike>(client: &C, key: Key, members: MultipleValues) -> Result<Value, Error> {
92  let frame = utils::request_response(client, move || {
93    let members = members.into_multiple_values();
94    let mut args = Vec::with_capacity(1 + members.len());
95    args.push(key.into());
96
97    for member in members.into_iter() {
98      args.push(member);
99    }
100    Ok((CommandKind::Smismember, args))
101  })
102  .await?;
103
104  protocol_utils::frame_to_results(frame)
105}
106
107pub async fn smembers<C: ClientLike>(client: &C, key: Key) -> Result<Value, Error> {
108  one_arg_values_cmd(client, CommandKind::Smembers, key.into()).await
109}
110
111pub async fn smove<C: ClientLike>(client: &C, source: Key, dest: Key, member: Value) -> Result<Value, Error> {
112  let args = vec![source.into(), dest.into(), member];
113  args_value_cmd(client, CommandKind::Smove, args).await
114}
115
116pub async fn spop<C: ClientLike>(client: &C, key: Key, count: Option<usize>) -> Result<Value, Error> {
117  let frame = utils::request_response(client, move || {
118    let mut args = Vec::with_capacity(2);
119    args.push(key.into());
120
121    if let Some(count) = count {
122      args.push(count.try_into()?);
123    }
124    Ok((CommandKind::Spop, args))
125  })
126  .await?;
127
128  protocol_utils::frame_to_results(frame)
129}
130
131pub async fn srandmember<C: ClientLike>(client: &C, key: Key, count: Option<usize>) -> Result<Value, Error> {
132  let frame = utils::request_response(client, move || {
133    let mut args = Vec::with_capacity(2);
134    args.push(key.into());
135
136    if let Some(count) = count {
137      args.push(count.try_into()?);
138    }
139    Ok((CommandKind::Srandmember, args))
140  })
141  .await?;
142
143  protocol_utils::frame_to_results(frame)
144}
145
146pub async fn srem<C: ClientLike>(client: &C, key: Key, members: MultipleValues) -> Result<Value, Error> {
147  let frame = utils::request_response(client, move || {
148    let members = members.into_multiple_values();
149    let mut args = Vec::with_capacity(1 + members.len());
150    args.push(key.into());
151
152    for member in members.into_iter() {
153      args.push(member);
154    }
155    Ok((CommandKind::Srem, args))
156  })
157  .await?;
158
159  protocol_utils::frame_to_results(frame)
160}
161
162pub async fn sunion<C: ClientLike>(client: &C, keys: MultipleKeys) -> Result<Value, Error> {
163  let frame = utils::request_response(client, move || {
164    let mut args = Vec::with_capacity(keys.len());
165
166    for key in keys.inner().into_iter() {
167      args.push(key.into());
168    }
169    Ok((CommandKind::Sunion, args))
170  })
171  .await?;
172
173  protocol_utils::frame_to_results(frame)
174}
175
176pub async fn sunionstore<C: ClientLike>(client: &C, dest: Key, keys: MultipleKeys) -> Result<Value, Error> {
177  let frame = utils::request_response(client, move || {
178    let mut args = Vec::with_capacity(1 + keys.len());
179    args.push(dest.into());
180
181    for key in keys.inner().into_iter() {
182      args.push(key.into());
183    }
184    Ok((CommandKind::Sunionstore, args))
185  })
186  .await?;
187
188  protocol_utils::frame_to_results(frame)
189}
fred/commands/impls/sets.rs

fred/commands/impls/
sets.rs
