userver: userver/storages/redis/command_options.hpp Source File
Loading...
Searching...
No Matches
command_options.hpp
1#pragma once
2
3#include <optional>
4#include <string>
5#include <vector>
6
7#include <userver/storages/redis/base.hpp>
8#include <userver/storages/redis/command_control.hpp>
9#include <userver/storages/redis/exception.hpp>
10#include <userver/storages/redis/scan_tag.hpp>
11
12USERVER_NAMESPACE_BEGIN
13
14namespace storages::redis {
15
16using Longitude = utils::StrongTypedef<struct LongitudeTag, double>;
17using Latitude = utils::StrongTypedef<struct LatitudeTag, double>;
18using BoxWidth = utils::StrongTypedef<struct BoxWidthTag, double>;
19using BoxHeight = utils::StrongTypedef<struct BoxHeightTag, double>;
20
21struct RangeOptions {
22 std::optional<size_t> offset;
23 std::optional<size_t> count;
24};
25
26struct GeoaddArg {
27 double lon;
28 double lat;
29 std::string member;
30};
31
32struct GeoradiusOptions {
33 enum class Sort { kNone, kAsc, kDesc };
34 enum class Unit { kM, kKm, kMi, kFt };
35
36 Unit unit = Unit::kM;
37 bool withcoord = false;
38 bool withdist = false;
39 bool withhash = false;
40 size_t count = 0;
41 Sort sort = Sort::kNone;
42};
43
44struct GeosearchOptions {
45 enum class Sort { kNone, kAsc, kDesc };
46 enum class Unit { kM, kKm, kMi, kFt };
47
48 Unit unit = Unit::kM;
49 bool withcoord = false;
50 bool withdist = false;
51 bool withhash = false;
52 size_t count = 0;
53 Sort sort = Sort::kNone;
54};
55
56struct ZaddOptions {
57 enum class Exist { kAddAlways, kAddIfNotExist, kAddIfExist };
58 enum class Compare { kNone, kGreaterThan, kLessThan };
59 enum class ReturnValue { kAddedCount, kChangedCount };
60
61 ZaddOptions() = default;
62 constexpr ZaddOptions(
63 Exist exist,
64 ReturnValue return_value = ReturnValue::kAddedCount,
65 Compare compare = Compare::kNone
66 )
67 : exist(exist), compare(compare), return_value(return_value) {}
68 constexpr ZaddOptions(Exist exist, Compare compare, ReturnValue return_value = ReturnValue::kAddedCount)
69 : exist(exist), compare(compare), return_value(return_value) {}
70
71 constexpr ZaddOptions(ReturnValue return_value, Exist exist = Exist::kAddAlways, Compare compare = Compare::kNone)
72 : exist(exist), compare(compare), return_value(return_value) {}
73 constexpr ZaddOptions(ReturnValue return_value, Compare compare, Exist exist = Exist::kAddAlways)
74 : exist(exist), compare(compare), return_value(return_value) {}
75
76 constexpr ZaddOptions(
77 Compare compare,
78 Exist exist = Exist::kAddAlways,
79 ReturnValue return_value = ReturnValue::kAddedCount
80 )
81 : exist(exist), compare(compare), return_value(return_value) {}
82 constexpr ZaddOptions(Compare compare, ReturnValue return_value, Exist exist = Exist::kAddAlways)
83 : exist(exist), compare(compare), return_value(return_value) {}
84
85 Exist exist = Exist::kAddAlways;
86 Compare compare = Compare::kNone;
87 ReturnValue return_value = ReturnValue::kAddedCount;
88};
89
90constexpr ZaddOptions operator|(ZaddOptions::Exist exist, ZaddOptions::ReturnValue return_value) {
91 return {exist, return_value};
92}
93constexpr ZaddOptions operator|(ZaddOptions::Exist exist, ZaddOptions::Compare compare) { return {exist, compare}; }
94constexpr ZaddOptions operator|(ZaddOptions::Compare compare, ZaddOptions::Exist exist) { return {compare, exist}; }
95constexpr ZaddOptions operator|(ZaddOptions::Compare compare, ZaddOptions::ReturnValue return_value) {
96 return {compare, return_value};
97}
98constexpr ZaddOptions operator|(ZaddOptions::ReturnValue return_value, ZaddOptions::Exist exist) {
99 return {return_value, exist};
100}
101constexpr ZaddOptions operator|(ZaddOptions::ReturnValue return_value, ZaddOptions::Compare compare) {
102 return {return_value, compare};
103}
104
105class ScanOptionsBase {
106public:
107 ScanOptionsBase() = default;
108 ScanOptionsBase(ScanOptionsBase& other) = default;
109 ScanOptionsBase(const ScanOptionsBase& other) = default;
110
111 ScanOptionsBase(ScanOptionsBase&& other) = default;
112
113 template <typename... Args>
114 ScanOptionsBase(Args&&... args) {
115 (Apply(std::forward<Args>(args)), ...);
116 }
117
118 class Match {
119 public:
120 explicit Match(std::string value) : value_(std::move(value)) {}
121
122 const std::string& Get() const& { return value_; }
123
124 std::string Get() && { return std::move(value_); }
125
126 private:
127 std::string value_;
128 };
129
130 class Count {
131 public:
132 explicit Count(size_t value) : value_(value) {}
133
134 size_t Get() const { return value_; }
135
136 private:
137 size_t value_;
138 };
139
140 std::optional<Match> ExtractMatch() { return std::move(pattern_); }
141
142 std::optional<Count> ExtractCount() { return std::move(count_); }
143
144private:
145 void Apply(Match pattern) {
146 if (pattern_) throw InvalidArgumentException("duplicate Match parameter");
147 pattern_ = std::move(pattern);
148 }
149
150 void Apply(Count count) {
151 if (count_) throw InvalidArgumentException("duplicate Count parameter");
152 count_ = count;
153 }
154
155 std::optional<Match> pattern_;
156 std::optional<Count> count_;
157};
158
159// strong typedef
160template <ScanTag scan_tag>
161class ScanOptionsTmpl : public ScanOptionsBase {
162 using ScanOptionsBase::ScanOptionsBase;
163};
164
165using ScanOptions = ScanOptionsTmpl<ScanTag::kScan>;
166using SscanOptions = ScanOptionsTmpl<ScanTag::kSscan>;
167using HscanOptions = ScanOptionsTmpl<ScanTag::kHscan>;
168using ZscanOptions = ScanOptionsTmpl<ScanTag::kZscan>;
169
170struct SetOptions {
171 enum class Exist { kSetAlways, kSetIfNotExist, kSetIfExist };
172
173 int seconds = 0;
174 int milliseconds = 0;
175 Exist exist = Exist::kSetAlways;
176};
177
178struct ScoreOptions {
179 bool withscores = false;
180};
181
182struct RangeScoreOptions {
183 ScoreOptions score_options;
184 RangeOptions range_options;
185};
186
187} // namespace storages::redis
188
189USERVER_NAMESPACE_END