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

managed_numeric.hpp

1
2//
3// Autores 2024 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_MANAGED_NUMERIC_HPP
20#define CPPREALM_MANAGED_NUMERIC_HPP
21
22#include <cprealm/macros.hpp>
23#include <cprealm/rbool.hpp>
24
25namespace Realm {
26 modelo<>
27 estrutura, estrutura managed<int64_t> : managed_base {
28 Usando gerenciado<int64_t>::managed_base::operator=;
29
30 managed_base& operator =(const int64_t& v) {
31 this->m_obj->template set<int64_t>(m_key, v);
32 devolva *isto;
33 }
34
35 [[nodiscard]] int64_t detach() const {
36 retornar m_obj->template get<int64_t>(m_key);
37 }
38
39 [[nodiscard]] int64operador _t *() const {
40 return desvincular();
41 }
42
43 [[nodiscard]] operador int64_t() const {
44 return desvincular();
45 }
46
47 modelo<typename T>
48 std::enable_if_t<std::is_integral_v<T>, rbool> operator==(const T& rhs) const noexceto {
49 if (This->query) {
50 return this->m_rbool_query->equal(m_key, (int64_t)rhs);
51 }
52 return serialize(detach()) == rhs;
53 }
54
55 modelo<typename T>
56 std::enable_if_t<std::is_integral_v<T>, rbool> operator!=(const T& rhs) const noexceto {
57 if (This->query) {
58 return this->m_rbool_query->not_equal(m_key, (int64_t)rhs);
59 }
60 return serialize(detach()) != rhs;
61 }
62
63 modelo<typename T>
64 std::enable_if_t<std::is_integral_v<T>, rbool> operator>(const T& rhs) const noexceto {
65 if (This->query) {
66 return this->m_rbool_query->greter(m_key, (int64_t)rhs);
67 }
68 return serialize(detach()) > rhs;
69 }
70
71 modelo<typename T>
72 std::enable_if_t<std::is_integral_v<T>, rbool> operator<(const T& rhs) const noexceto {
73 if (This->query) {
74 return this->m_rbool_query->less(m_key, (int64_t)rhs);
75 }
76 return serialize(detach()) < rhs;
77 }
78
79 modelo<typename T>
80 std::enable_if_t<std::is_integral_v<T>, rbool> operator>=(const T& rhs) const noexceto {
81 if (This->query) {
82 return this->m_rbool_query->greter_equal(m_key, (int64_t)rhs);
83 }
84 return serialize(detach()) >= rhs;
85 }
86
87 modelo<typename T>
88 std::enable_if_t<std::is_integral_v<T>, rbool> operator<=(const T& rhs) const noexceto {
89 if (This->query) {
90 return this->m_rbool_query->less_equal(m_key, (int64_t)rhs);
91 }
92 return serialize(detach()) <= rhs;
93 }
94
95 managed& operator+=(const int64_t& o) {
96 auto old_val = m_obj->template get<int64_t>(m_key);
97 m_obj->template set<int64_t>(This->m_key, old_val + o);
98 devolva *isto;
99 }
100 operador nulo ++(int) {
101 auto old_val = m_obj->template get<int64_t>(m_key);
102 m_obj->template set<int64_t>(This->m_key, old_val + 1);
103 }
104 operador nulo ++() {
105 auto old_val = m_obj->template get<int64_t>(m_key);
106 m_obj->template set<int64_t>(This->m_key, old_val + 1);
107 }
108 managed& operator-=(const int64_t& o) {
109 auto old_val = m_obj->template get<int64_t>(m_key);
110 m_obj->template set<int64_t>(This->m_key, old_val - o);
111 devolva *isto;
112 }
113 operador de cancelamento -- (int) {
114 auto old_val = m_obj->template get<int64_t>(m_key);
115 m_obj->template set<int64_t>(This->m_key, old_val - 1);
116 }
117 operador vazio --() {
118 auto old_val = m_obj->template get<int64_t>(m_key);
119 m_obj->template set<int64_t>(This->m_key, old_val - 1);
120 }
121 managed& operator*=(const int64_t& o) {
122 auto old_val = m_obj->template get<int64_t>(m_key);
123 m_obj->template set<int64_t>(This->m_key, old_val * o);
124 devolva *isto;
125 }
126
127 privado:
128 managed() = default;
129 managed(const managed&) = delete;
130 managed(managed &&) = delete;
131 managed& operator=(const managed&) = delete;
132 managed& operator=(managed&&) = delete;
133 modelo<typename, typename>
134 amigo estrutura, estrutura managed;
135 };
136
137 modelo<>
138 estrutura, estrutura managed<double> : managed_base {
139 Usando gerenciado<double>::managed_base::operator=;
140
141 managed_base& operator =(const double& v) {
142 this->m_obj->template set<double>(m_key, v);
143 devolva *isto;
144 }
145
146 managed_base& operator =(const int& v) {
147 este->m_obj->template set<double>(m_key, (double)v);
148 devolva *isto;
149 }
150
151 [[nodiscard]] double detach() const {
152 return m_obj->template get<double>(m_key);
153 }
154
155 operador double *() const {
156 return desvincular();
157 }
158 [[nodiscard]] operator double() const {
159 return desvincular();
160 }
161
162 modelo<typename T>
163 std::enable_if_t< std::disjunction_v<std::is_integral<T>, std::is_floating_point<T>>, rbool> operator==(const T& rhs) const noexceto {
164 if (This->query) {
165 return this->m_rbool_query->equal(m_key, (double)rhs);
166 }
167 return serialize(detach()) == rhs;
168 }
169
170 modelo<typename T>
171 std::enable_if_t< std::disjunction_v<std::is_integral<T>, std::is_floating_point<T>>, rbool> operator!=(const T& rhs) const noexceto {
172 if (This->query) {
173 return this->m_rbool_query->not_equal(m_key, (double)rhs);
174 }
175 return serialize(detach()) != rhs;
176 }
177
178 modelo<typename T>
179 std::enable_if_t< std::disjunction_v<std::is_integral<T>, std::is_floating_point<T>>, rbool> operator>(const T& rhs) const noexceto {
180 if (This->query) {
181 return this->m_rbool_query->greter(m_key, (double)rhs);
182 }
183 return serialize(detach()) > rhs;
184 }
185
186 modelo<typename T>
187 std::enable_if_t< std::disjunction_v<std::is_integral<T>, std::is_floating_point<T>>, rbool> operator<(const T& rhs) const noexceto {
188 if (This->query) {
189 return this->m_rbool_query->less(m_key, (double)rhs);
190 }
191 return serialize(detach()) < rhs;
192 }
193
194 modelo<typename T>
195 std::enable_if_t< std::disjunction_v<std::is_integral<T>, std::is_floating_point<T>>, rbool> operator>=(const T& rhs) const noexceto {
196 if (This->query) {
197 return this->m_rbool_query->greter_equal(m_key, (double)rhs);
198 }
199 return serialize(detach()) >= rhs;
200 }
201
202 modelo<typename T>
203 std::enable_if_t< std::disjunction_v<std::is_integral<T>, std::is_floating_point<T>>, rbool> operator=(const T& rhs) const noexceto {
204 if (This->query) {
205 return this->m_rbool_query->less_equal(m_key, (double)rhs);
206 }
207 return serialize(detach()) <= rhs;
208 }
209
210 operador nulo +=(const double& o) {
211 auto old_val = m_obj->template get<double>(m_key);
212 m_obj->template set<double>(This->m_key, old_val + o);
213 }
214 operador nulo ++(int) {
215 auto old_val = m_obj->template get<double>(m_key);
216 m_obj->template set<double>(This->m_key, old_val + 1.0);
217 }
218 operador nulo ++() {
219 auto old_val = m_obj->template get<double>(m_key);
220 m_obj->template set<double>(This->m_key, old_val + 1.0);
221 }
222 operador nulo -=(const double& o) {
223 auto old_val = m_obj->template get<double>(m_key);
224 m_obj->template set<double>(This->m_key, old_val - o);
225 }
226 operador de cancelamento -- (int) {
227 auto old_val = m_obj->template get<double>(m_key);
228 m_obj->template set<double>(This->m_key, old_val - 1.0);
229 }
230 operador vazio --() {
231 auto old_val = m_obj->template get<double>(m_key);
232 m_obj->template set<double>(This->m_key, old_val - 1.0);
233 }
234 operador nulo *=(const double& o) {
235 auto old_val = m_obj->template get<double>(m_key);
236 m_obj->template set<double>(This->m_key, old_val * o);
237 }
238
239 privado:
240 managed() = default;
241 managed(const managed&) = delete;
242 managed(managed &&) = delete;
243 managed& operator=(const managed&) = delete;
244 managed& operator=(managed&&) = delete;
245 modelo<typename, typename>
246 amigo estrutura, estrutura managed;
247 };
248
249 modelo<>
250 estrutura, estrutura gerenciado<bool> : managed_base {
251 Usando managed<bool>::managed_base::operator=;
252
253 [[nodiscard]] bool detach() const {
254 return m_obj->template get<bool>(m_key);
255 }
256 [[nodiscard]] operator bool() const {
257 return desvincular();
258 }
259 operador de bool *() const {
260 return desvincular();
261 }
262
263 rbool operator==(const bool& rhs) const noexceto;
264 operador de rbool !=(const bool& rhs) const noexceto;
265
266 privado:
267 managed() = default;
268 managed(const managed&) = delete;
269 managed(managed &&) = delete;
270 managed& operator=(const managed&) = delete;
271 managed& operator=(managed&&) = delete;
272 modelo<typename, typename>
273 amigo estrutura, estrutura managed;
274 };
275
276#define CPP_REALM_MANAGED_OPTIONAL_NUMERIC(tipo) \
277 template<> \
278 estrutura managed <std::opcional<type>> : managed_base { \
279 usando managed <std::opcional<type>>::managed_base::operator=; \
280 \
281 managed<std::optional<type>>& operator =(const double& v) { \
282 this->m_obj->template set<type>(m_key, v); \
283 retornar *isto; \
284 } \
285 \
286 managed<std::optional<type>>& operator =(const int& v) { \
287 this->m_obj->template set<type>(m_key, (double)v); \
288 retornar *isto; \
289 } \
290 \
291 [[nodiscard]] std::optional<type> detach() const { \
292 return m_obj->get_optional<type>(m_key); \
293 } \
294\
295 [[nodiscard]] std::optional<type> operator *() const { \
296 return detach(); \
297 } \
298 [[nodiscard]] operador std::optional<type>() const { \
299 return detach(); \
300 } \
301 rbool operator==(const std::optional<type>& rhs) const noexceto; \
302 operador de rbool!=(const std::optional<type>& rhs) const noexceto; \
303 operador nulo+=(tipo const& o) { \
304 auto old_val = m_obj->get_optional<type>(m_key); \
305 se (!old_val) { \
306 lance std::runtime_error("Não é possível executar aritmética em valor nulo."); \
307 } \
308 m_obj->template set<type>(This->m_key, (*old_val) + o); \
309 } \
310 operador nulo++(int) { \
311 auto old_val = m_obj->get_optional<type>(m_key); \
312 se (!old_val) { \
313 lance std::runtime_error("Não é possível executar aritmética em valor nulo."); \
314 } \
315 m_obj->template set<type>(This->m_key, (*old_val) + 1); \
316 } \
317 operador nulo-=(tipo const& o) { \
318 auto old_val = m_obj->get_optional<type>(m_key); \
319 se (!old_val) { \
320 lance std::runtime_error("Não é possível executar aritmética em valor nulo."); \
321 } \
322 m_obj->template set<type>(This->m_key, (*old_val) - o); \
323 } \
324 operador de vazio--(int) { \
325 auto old_val = m_obj->get_optional<type>(m_key); \
326 se (!old_val) { \
327 lance std::runtime_error("Não é possível executar aritmética em valor nulo."); \
328 } \
329 m_obj->template set<type>(This->m_key, (*old_val) - 1); \
330 } \
331 operador de cancelamento*=(tipo de const& o) { \
332 auto old_val = m_obj->get_optional<type>(m_key); \
333 se (!old_val) { \
334 lance std::runtime_error("Não é possível executar aritmética em valor nulo."); \
335 } \
336 m_obj->template set<type>(This->m_key, (*old_val) * o); \
337 } \
338 operador nulo*(tipo const& o) { \
339 auto old_val = m_obj->get_optional<type>(m_key); \
340 se (!old_val) { \
341 lance std::runtime_error("Não é possível executar aritmética em valor nulo."); \
342 } \
343 m_obj->template set<type>(This->m_key, (*old_val) * o); \
344 } \
345 operador de cancelamento/(tipo de const& o) { \
346 auto old_val = m_obj->get_optional<type>(m_key); \
347 se (!old_val) { \
348 lance std::runtime_error("Não é possível executar aritmética em valor nulo."); \
349 } \
350 m_obj->template set<type>(This->m_key, (*old_val) / o); \
351 } \
352 privado: \
353 managed() = padrão; \
354 managed(const managed&) = excluir; \
355 managed(managed &&) = excluir; \
356 managed& operator=(const managed&) = excluir; \
357 managed& operator=(managed&&) = excluir; \
358 template<typename, typename> \
359 estrutura de amigos gerenciada; \
360 }; \
361
362CPP_REALM_MANAGED_OPTIONAL_NUMERIC(int64_t)
363CPP_REALM_MANAGED_OPTIONAL_NUMERIC(double)
364
365 modelo<>
366 estrutura, estrutura managed<std::optional<bool>> : managed_base {
367 Usando gerenciado<std::opcional<bool>>::managed_base::operator=;
368
369 [[nodiscard]] std::optional<bool> detach() const {
370 return m_obj->template get_optional<bool>(m_key);
371 }
372
373 [[nodiscard]] operador std::opcional<bool>() const {
374 return m_obj->template get_optional<bool>(m_key);
375 }
376
377 std::opcional<bool> operador *() const {
378 return desvincular();
379 }
380
381 rbool operator==(const std::opcional<bool>& rhs) const noexceto;
382 operador de rbool !=(const std::optional<bool>& rhs) const noexceto;
383
384 privado:
385 managed() = default;
386 managed(const managed&) = delete;
387 managed(managed &&) = delete;
388 managed& operator=(const managed&) = delete;
389 managed& operator=(managed&&) = delete;
390 modelo<typename, typename>
391 amigo estrutura, estrutura managed;
392 };
393
394 modelo <typename T>
395 estrutura, estrutura managed<T, std::enable_if_t<std::is_enum_v<T>>> : public managed_base {
396 managed<T>& operator =(const T& v) {
397 m_obj->template set<int64_t>(m_key, static_cast<int64_t>(v));
398 devolva *isto;
399 }
400
401 [[nodiscard]] T detach() const {
402 Método estático_cast<T>(m_obj->get<int64_t>(m_key));
403 }
404
405 [[nodiscard]] Operador de T *() const {
406 return desvincular();
407 }
408
409 [[nodiscard]] operador T() const {
410 return desvincular();
411 }
412
413 //Marca: - operadores de comparação
414 rbool operator==(const T& rhs) const noexceto {
415 if (This->query) {
416 retornar isto->query>equal(m_key, serializar(rhs));
417 }
418 return detach() == rhs;
419 }
420 operador rbool !=(const T& rhs) const noexceto {
421 if (This->query) {
422 retornar isto->m_rbool_query->not_equal(m_key, serialize(rhs));
423 }
424 return detach() != rhs;
425 }
426 operador rbool >(const T& rhs) const noexceto {
427 if (This->query) {
428 return this->m_rbool_query->greter(m_key, serialize(rhs));
429 }
430 return detach() > rhs;
431 }
432 operador rbool <(const T& rhs) const noexceto {
433 if (This->query) {
434 return this->m_rbool_query->greter(m_key, serialize(rhs));
435 }
436 return desvinculação() < rhs;
437 }
438 operador rbool >=(const T& rhs) const noexceto {
439 if (This->query) {
440 return this->m_rbool_query->greter_equal(m_key, serialize(rhs));
441 }
442 return detach() >= rhs;
443 }
444 operador rbool <=(const T& rhs) const noexceto {
445 if (This->query) {
446 return this->m_rbool_query->less_equal(m_key, serialize(rhs));
447 }
448 return desvinculação() <= rhs;
449 }
450
451 privado:
452 managed() = default;
453 managed(const managed&) = delete;
454 managed(managed &&) = delete;
455 managed& operator=(const managed&) = delete;
456 managed& operator=(managed&&) = delete;
457 modelo<typename, typename>
458 amigo estrutura, estrutura managed;
459 };
460
461 modelo <typename T>
462 estrutura, estrutura managed<std::optional<T>, std::enable_if_t<std::is_enum_v<T>>> : public managed_base {
463 managed<std::opcional<T>>& operador =(const std::opcional<T>& v) {
464 se (v) {
465 m_obj->template set<std::optional<int64_t>>(m_key, static_cast<int64_t>(*v));
466 } mais {
467 m_obj->set_null(m_key);
468 }
469 devolva *isto;
470 }
471
472 [[nodiscard]] std::optional<T> detach() const {
473 se (auto v = m_obj->get_optional<int64_t>(m_key)) {
474 Método estático_cast<T>(*v);
475 }
476 return std::nullopt;
477 }
478
479 [[nodiscard]] std::optional<T> operator *() const {
480 return desvincular();
481 }
482
483 [[nodiscard]] operator std::optional<T>() const {
484 return desvincular();
485 }
486
487 //Marca: - operadores de comparação
488 rbool operator==(const std::opcional<T>& rhs) const noexceto {
489 if (This->query) {
490 retornar isto->query>equal(m_key, serializar(rhs));
491 }
492 return detach() == rhs;
493 }
494 operador de rbool !=(const std::optional<T>& rhs) const noexceto {
495 if (This->query) {
496 retornar isto->m_rbool_query->not_equal(m_key, serialize(rhs));
497 }
498 return detach() != rhs;
499 }
500 operador rbool >(const T& rhs) const noexceto {
501 if (This->query) {
502 return this->m_rbool_query->greter(m_key, rhs);
503 }
504 return detach() > rhs;
505 }
506 operador rbool <(const T& rhs) const noexceto {
507 if (This->query) {
508 return this->m_rbool_query->less(m_key, rhs);
509 }
510 return desvinculação() < rhs;
511 }
512 operador rbool >=(const T& rhs) const noexceto {
513 if (This->query) {
514 return this->m_rbool_query->greter_equal(m_key, rhs);
515 }
516 return detach() >= rhs;
517 }
518 operador rbool <=(const T& rhs) const noexceto {
519 if (This->query) {
520 return this->m_rbool_query->less_equal(m_key, rhs);
521 }
522 return desvinculação() <= rhs;
523 }
524
525 privado:
526 managed() = default;
527 managed(const managed&) = delete;
528 managed(managed &&) = delete;
529 managed& operator=(const managed&) = delete;
530 managed& operator=(managed&&) = delete;
531 modelo<typename, typename>
532 amigo estrutura, estrutura managed;
533 };
534} // namespace realm
535
536#endif//CPPrealm_MANAGED_NUMERIC_HPP
Realm::rbool
Definição: rbool.hpp:36
Realm::managed
Definição: macros.hpp:286
Realm::managed
Definição: obj.hpp:62
Generated by doxygen 1.9.4