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