Realm C++ SDK Versão C++ v2.2.0

rbool.hpp

1
2//
3// Autores 2022 Realm Inc.
4//
5// Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
6// você não pode usar este arquivo, exceto em conformidade com a Licença.
7// Você pode obter uma cópia da Licença em
8//
9// http://www.apache.org/license/LICENSE-2.0
10//
11// A menos que exigido pela lei aplicável ou acordado por escrito, o software
12// distribuído sob a Licença é distribuído "Como está",
13// sem garantias ou condições de qualquer tipo, Express ou implícitas.
14// Consulte a Licença para obter as permissões específicas de domínio do idioma e
15// limitações da Licença.
16//
18
19#ifndef CPPREALM_RBOOL_HPP
20#define CPPREALM_RBOOL_HPP
21
22#include <cpprealm/internal/bridge/query.hpp>
23#include <cprealm/internal/bridge/realm.hpp>
24#include <cprealm/internal/bridge/table.hpp>
25#include <cprealm/internal/bridge/utils.hpp>
26#include <cprealm/types.hpp>
27
28namespace Realm {
29 modelo<nome do tipo>
30 struct box_base;
31}
32
33namespace Realm {
34 // MARK: rbool
35
36 classe rbool {
37 público:
38 estrutura, estrutura dictionary_context {
39 internal::bridge::col_key origin_col_key;
40 std::string m_key;
41 };
42
43 rbool& add_link_chain(const internal::bridge::col_key& col_key) {
44 se (m_link_chain) {
45 m_link_chain->link(col_key);
46 } mais {
47 m_link_chain = m_table.get_link(col_key);
48 }
49 devolva *isto;
50 }
51
52#define define_query(tipo, comparação) \
53 rbool& comparison(const internal::bridge::col_key& col_key, const std::optional<type>& rhs) { \
54 se (auto lc = m_link_chain) { \
55 q = lc->column<type>(col_key).comparison(rhs); \
56 m_link_chain = std::nullopt; \
57 } mais se (m_Dictionary_ctx) { \
58 q = q.Dictionary_link_subexpr(m_Dictionary_ctx->origin_col_key, col_key, m_Dictionary_ctx->m_key).comparison(rhs); \
59 m_Dictionary_ctx = std::nullopt; \
60 } mais { \
61 se (rhs) { \
62 q = internal::bridge::query(q.get_table()).comparison(col_key, *rhs); \
63 } mais { \
64 q = internal::bridge::query(q.get_table()).comparison(col_key, std::nullopt); \
65 } \
66 } \
67 retornar *isto; \
68 } \
69 rbool& comparison(const internal::bridge::col_key& col_key, const type& rhs) { \
70 se (auto lc = m_link_chain) { \
71 q = lc->column<type>(col_key).comparison(std::optional<type>(rhs)); \
72 m_link_chain = std::nullopt; \
73 } mais se (m_Dictionary_ctx) { \
74 q = q.Dictionary_link_subexpr(m_Dictionary_ctx->origin_col_key, col_key, m_Dictionary_ctx->m_key).comparison(std::optional<type>(rhs)); \
75 m_Dictionary_ctx = std::nullopt; \
76 } mais { \
77 q = internal::bridge::query(q.get_table()).comparison(col_key, rhs); \
78 } \
79 retornar *isto; \
80 }
81
82#define define_numeric_query(tipo, comparação) \
83 rbool& comparison(const internal::bridge::col_key& col_key, const type& rhs) { \
84 se (auto lc = m_link_chain) { \
85 q = lc->column<type>(col_key).comparison(:: Realm::serialize(std::optional<type>(rhs))); \
86 m_link_chain = std::nullopt; \
87 } mais se (m_Dictionary_ctx) { \
88 q = q.Dictionary_link_subexpr(m_Dictionary_ctx->origin_col_key, col_key, m_Dictionary_ctx->m_key).comparison(std::optional<type>(rhs)); \
89 m_Dictionary_ctx = std::nullopt; \
90 } mais { \
91 q = internal::bridge::query(q.get_table()).comparison(col_key, rhs); \
92 } \
93 retornar *isto; \
94 }
95
96 define_query(std::string, equal)
97 define_query(std::string, not_equal)
98
99 rbool& contains(const internal::bridge::col_key& col_key, const std::string& rhs, bool case_sensitive = true) {
100 if (auto lc = m_link_chain) {
101 q = lc->column<std::string>(col_key).contains(:: Realm::serialize(std::optional<std::string>(rhs)), case_sensitive);
102 m_link_chain = std::nullopt;
103 } mais {
104 q = internal::bridge::query(q.get_table()).contains(col_key, rhs, case_sensitive);
105 }
106 devolva *isto;
107 }
108
109 define_query(int64_t, igual)
110 define_query(int64_t, not_equal)
111 define_numeric_query(int64_t, maior)
112 define_numeric_query(int64_t, menos)
113 define_numeric_query(int64_t, maior_equal)
114 define_numeric_query(int64_t, less_equal)
115
116 define_query(bool, equal)
117 define_query(bool, not_equal)
118
119 define_query(double, igual)
120 define_query(double, not_equal)
121 define_numeric_query(double, maior)
122 define_numeric_query(double, menos)
123 define_numeric_query(double, maior_equal)
124 define_numeric_query(double, less_equal)
125
126 define_query(std::vector<uint8_t>, equal)
127 define_query(std::vector<uint8_t>, not_equal)
128
129 define_query(std::chrono::time_point,<std::chrono::system_clock> equal)
130 define_query(std::chrono::time_point,<std::chrono::system_clock> not_equal)
131 define_numeric_query(std::chrono::time_point<std::chrono::system_clock>, maior)
132 define_numeric_query(std::chrono::time_point<std::chrono::system_clock>, menos)
133 define_numeric_query(std::chrono::time_point,<std::chrono::system_clock> maior_equal)
134 define_numeric_query(std::chrono::time_point,<std::chrono::system_clock> less_equal)
135
136 define_query(uuid, equal)
137 define_query(uuid, not_equal)
138
139 define_query(object_id, equal)
140 define_query(object_id, not_equal)
141
142 define_query(decimal128, igual)
143 define_query(decimal128, not_equal)
144 define_numeric_query(decimal128, maior)
145 define_numeric_query(decimal128, menos)
146 define_numeric_query(decimal128, maior_equal)
147 define_numeric_query(decimal128, less_equal)
148
149 rbool& mixed_equal(const internal::bridge::col_key& col_key, const internal::bridge::mixed& rhs) {
150 if (auto lc = m_link_chain) {
151 q = lc->column<std::string>(col_key).mixed_equal(rhs);
152 m_link_chain = std::nullopt;
153 } mais {
154 q.equal(col_key, rhs);
155 }
156 devolva *isto;
157 }
158
159 rbool& mixed_not_equal(const internal::bridge::col_key& col_key, const internal::bridge::mixed& rhs) {
160 if (auto lc = m_link_chain) {
161 q = lc->column_mixed(col_key).mixed_not_equal(rhs);
162 m_link_chain = std::nullopt;
163 } mais {
164 q.not_equal(col_key, rhs);
165 }
166 devolva *isto;
167 }
168
169 rbool& link_equal(const internal::bridge::col_key& col_key, const std::optional<internal::bridge::obj>& rhs) {
170 if (auto lc = m_link_chain) {
171 q = lc->column<internal::bridge::obj>(col_key).equal(rhs);
172 m_link_chain = std::nullopt;
173 } mais {
174 se (rhs) {
175 q.links_to(col_key, *rhs);
176 } mais {
177 q.links_to(col_key, internal::bridge::obj());
178 }
179 }
180 devolva *isto;
181 }
182
183 rbool& link_not_equal(const internal::bridge::col_key& col_key, const std::optional<internal::bridge::obj>& rhs) {
184 if (auto lc = m_link_chain) {
185 q = lc->column<internal::bridge::obj>(col_key).not_equal(rhs);
186 m_link_chain = std::nullopt;
187 } mais {
188 se (rhs) {
189 q.not_links_to(col_key, *rhs);
190 } mais {
191 q.not_links_to(col_key, internal::bridge::obj());
192 }
193 }
194 devolva *isto;
195 }
196
197 // Dictionary
198
199 rbool& dictionary_has_value_for_key_equals(internal::bridge::col_key column_key, const std::string& key, const internal::bridge::mixed& value) {
200 q = internal::bridge::query(q.get_table()).Dictionary_has_value_for_key_equals(column_key, chave, valor);
201 devolva *isto;
202 }
203
204 rbool& dictionary_has_value_for_key_not_equals(internal::bridge::col_key column_key, const std::string& chave, const internal::bridge::mixed& valor) {
205 q = internal::bridge::query(q.get_table()).Dictionary_has_value_for_key_not_equals(column_key, chave, valor);
206 devolva *isto;
207 }
208
209 rbool& dictionary_has_value_for_key_greter_than(internal::bridge::col_key column_key, const std::string& key, const internal::bridge::mixed& value) {
210 q = internal::bridge::query(q.get_table()).Dictionary_has_value_for_key_greter_than(column_key, chave, valor);
211 devolva *isto;
212 }
213
214 rbool& dictionary_has_value_for_key_less_than(internal::bridge::col_key column_key, const std::string& key, const internal::bridge::mixed& value) {
215 q = internal::bridge::query(q.get_table()).Dictionary_has_value_for_key_less_than(column_key, chave, valor);
216 devolva *isto;
217 }
218
219 rbool& dictionary_has_value_for_key_greter_than_equals(internal::bridge::col_key column_key, const std::string& chave, const internal::bridge::mixed& valor) {
220 q = internal::bridge::query(q.get_table()).Dictionary_has_value_for_key_greter_than_equals(column_key, chave, valor);
221 devolva *isto;
222 }
223
224 rbool& dictionary_has_value_for_key_less_than_equals(internal::bridge::col_key column_key, const std::string& chave, const internal::bridge::mixed& valor) {
225 q = internal::bridge::query(q.get_table()).Dictionary_has_value_for_key_less_than_equals(column_key, chave, valor);
226 devolva *isto;
227 }
228
229 rbool& dictionary_contains_string_for_key(internal::bridge::col_key column_key, const std::string& chave, const std::string& valor) {
230 q = internal::bridge::query(q.get_table()).Dictionary_contains_string_for_key(column_key, chave, valor);
231 devolva *isto;
232 }
233
234 rbool& add_Dictionary_link_chain(Dictionary_context&& ctx) {
235 m_dictionary_ctx = ctx;
236 devolva *isto;
237 }
238
239 rbool& dictionary_has_key(internal::bridge::col_key column_key, const std::string& key) {
240 q = internal::bridge::query(q.get_table()).Dictionary_contains_key(column_key, chave);
241 devolva *isto;
242 }
243
244 ~rbool() {
245 if (is_for_queries)
246 q.~query();
247 }
248 operador bool() const {
249 retornar b;
250 }
251 Operador de rbool!() const {
252 se (is_for_queries) {
253 q.negal();
254 devolva *isto;
255 }
256 return !b;
257 }
258 união {
259 bool b;
260 interno mutável ::bridge::query q;
261 };
262
263 rbool(internal::bridge::query &&q) : q(q), is_for_queries(true) {
264 m_table = q.get_table();
265 }
266 rbool(bool b) : b(b) {}
267 rbool(const rbool &r) {
268 se (r.is_for_queries) {
269 novo (&q) internal::bridge::query(rq);
270 is_for_queries = true;
271 } else
272 b = r.b;
273 }
274
275 privado:
276 bool is_for_queries = false;
277 bool is_Dictionary_link = false;
278 std::optional<internal::bridge::link_chain> m_link_chain;
279 internal::bridge::table m_table;
280 std::opcional<dictionary_context> m_Dictionary_ctx;
281
282 modelo<typename T>
283 amigo estrutura de resultados;
284 operador amigo rbool&&(const rbool &lhs, const rbool &rhs);
285 operador amigo rbool||(const rbool &lhs, const rbool &rhs);
286 };
287
288 operador de rbool inline &&(const rbool& lhs, const rbool& rhs) {
289 se (lhs.is_for_queries) {
290 lhs.q.and_query(rhs.q);
291 return lhs;
292 }
293 retornar lhs.b && rhs.b;
294 }
295 operador inline rbool ||(const rbool& lhs, const rbool& rhs) {
296 se (lhs.is_for_queries) {
297 lhs.q = lhs.q || rhs.q;
298 return lhs;
299 }
300 retornar lhs.b && rhs.b;
301 }
302
304 modelo<typename T>
305 inline rbool truepredicate(const T& o) {
306 // Uma query vazia retorna todos os resultados e uma maneira de indicar isso
307 // é serializar TRUEPredicate que é funcionalmente equivalente
308 rbool* rb = internal::get_rbool(o);
309 se (rb == nullptr)
310 lance std::runtime_error("O objeto gerenciado não é usado em um contexto de consulta");
311 auto table = rb->q.get_table();
312 return rbool(tabela);
313 }
314
316 modelo<typename T>
317 inline rbool falsepredicate(const T& o) {
318 rbool* rb = internal::get_rbool(o);
319 se (rb == nullptr)
320 lance std::runtime_error("O objeto gerenciado não é usado em um contexto de consulta");
321 auto table = rb->q.get_table();
322 auto q = internal::bridge::query(table).and_query(internal::bridge::query(table).falsepredicate());
323 return rbool(std::move(q));
324 }
325}
326
327#endif //CPPrealm_RBOOL_HPP
Realm::rbool
Definição: rbool.hpp:36
realm::internal::bridge::col_key
Definição: col_key.hpp:28
Realm::rbool::Dictionary_context
Definição: rbool.hpp:38
Generated by doxygen 1.9.4