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

managed_primary_key.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_PRIMARY_KEY_HPP
20#define CPPREALM_MANAGED_PRIMARY_KEY_HPP
21
22#include <cprealm/macros.hpp>
23#include <cprealm/rbool.hpp>
24
25namespace Realm {
26 modelo <typename, typename>
27 estrutura managed;
28
29 modelo<typename T>
30 estrutura, estrutura primary_key {
31 primary_key() = default;
32 primary_key(const T& v) {
33 este->valor = v;
34 }
valor de 35 T;
36 usando Internal_type = T;
37 operador T() const {
38 valor de devolução ;
39 }
40 };
41
42 modelo<>
43 estrutura, estrutura primary_key<int64_t> {
44 usando Internal_type = int64_t;
45 primary_key() = default;
46 primary_key(const int64_t& v) {
47 este->valor = v;
48 }
49 primary_key(int int& v) {
50 este->valor = v;
51 }
52 valor int64_t;
53 operador int64_t() const {
54 valor de devolução ;
55 }
56 };
57
58 modelo<>
59 estrutura, estrutura primary_key<objeto> {
60 Usando initial_type = initial::bridge::objeto;
61 primary_key() = default;
62 primary_key(const objeto& v) {
63 este->valor = v;
64 }
65 valor objeto ;
66 operador, operador objeto() const {
67 valor de devolução ;
68 }
69 };
70
71 modelo<>
72 estrutura, estrutura primary_key<std::string> {
73 usando initial_type = std::string;
74 primary_key() = default;
75 primary_key(const std::string& v) {
76 este->valor = v;
77 }
78 primary_key(const caracteres* v) {
79 este->valor = v;
80 }
81 std::valor da string;
82 operador std::string() const {
83 valor de devolução ;
84 }
85 };
86
87 modelo<>
88 estrutura, estrutura primary_key<uuid> {
89 Usando initial_type = initial::bridge::uuid;
90 primary_key() = default;
91 primary_key(const uuid& v) {
92 este->valor = v;
93 }
94 valor uuid ;
95 operador, operador uuid() const {
96 valor de devolução ;
97 }
98 };
99
100 modelo<>
101 estrutura, estrutura primary_key<std::optional<int64_t>> {
102 usando Internal_type = std::optional<int64_t>;
103 primary_key() = default;
104 primary_key(const std::nullopt_t& v) {
105 este->valor = v;
106 }
107 primary_key(const std::optional<int64_t>& v) {
108 este->valor = v;
109 }
110 primary_key(const std::opcional<int>& v) {
111 este->valor = v;
112 }
113 primary_key(const int64_t& v) {
114 este->valor = v;
115 }
116 primary_key(int int& v) {
117 este->valor = v;
118 }
119 std::valor opcional<int64_t>;
120 operador std::opcional<int64_t>() const {
121 valor de devolução ;
122 }
123 };
124
125 modelo<>
126 estrutura, estrutura primary_key<std::optional<object_id>> {
127 usando Internal_type = std::opcional<internal::bridge::object_id>;
128 primary_key() = default;
129 primary_key(const std::nullopt_t& v) {
130 este->valor = v;
131 }
132 primary_key ( const std::optional<object_id>& v) {
133 este->valor = v;
134 }
135 primary_key(const objeto& v) {
136 este->valor = v;
137 }
138 std::valor opcional<object_id>;
139 operador std::opcional<object_id>() const {
140 valor de devolução ;
141 }
142 };
143
144 modelo<>
145 estrutura, estrutura primary_key<std::optional<std::string>> {
146 usando initial_type = std::opcional<std::string>;
147 primary_key() = default;
148 primary_key(const std::nullopt_t& v) {
149 este->valor = v;
150 }
151 primary_key(const std::optional<std::string>& v) {
152 este->valor = v;
153 }
154 primary_key(const std::string& v) {
155 este->valor = v;
156 }
157 primary_key(const caracteres* v) {
158 este->valor = v;
159 }
160 std::valor opcional<std::string>;
161 operador std::opcional<std::string>() const {
162 valor de devolução ;
163 }
164 };
165
166 modelo<>
167 estrutura, estrutura primary_key<std::optional<uuid>> {
168 usando Internal_type = std::opcional<internal::bridge::uuid>;
169 primary_key() = default;
170 primary_key(const std::nullopt_t& v) {
171 este->valor = v;
172 }
173 primary_key(const std::optional<uuid>& v) {
174 este->valor = v;
175 }
176 primary_key(const uuid& v) {
177 este->valor = v;
178 }
179 std::valor<uuid> opcional;
180 operador std::opcional<uuid>() const {
181 valor de devolução ;
182 }
183 };
184
185 modelo<>
186 estrutura, estrutura managed<primary_key<int64_t>> final : managed_base {
187 primary_key<int64_t> detach() const {
188 Método operador int64_t();
189 }
190
191 operador int64_t() const {
192 retornar m_obj->template get<int64_t>(m_key);
193 }
194
195 rbool operator==(const int64_t& rhs) const noexceto;
196 operador rbool !=(const int64_t& rhs) const noexceto;
197 rbool operator>(const int64_t& RHs) const noexceto;
198 rbool operator>=(const int64_t& RHs) const noexceto;
199 operador rbool <(const int64_t& RHs) const noexceto;
200 operador rbool <=(const int64_t& RHs) const noexceto;
201 rbool operator==(const int& rhs) const noexceto;
202 operador rbool !=(const int& rhs) const noexceto;
203 rbool operator>(const int& RHs) const noexceto;
204 rbool operator>=(const int& rhs) const noexceto;
205 operador rbool <(const int& rhs) const noexceto;
206 operador rbool <=(const int& rhs) const noexceto;
207
208 privado:
209 managed() = default;
210 managed(const managed&) = delete;
211 managed(managed &&) = delete;
212 managed& operator=(const managed&) = delete;
213 managed& operator=(managed&&) = delete;
214 modelo<typename, typename>
215 amigo estrutura, estrutura managed;
216 };
217
218 modelo<>
219 estrutura, estrutura managed<primary_key<std::string>> final : managed_base {
220 primary_key<std::string> detach() const {
221 Método operador std::string();
222 }
223
224 operador std::string() const {
225 retornar m_obj->template get<std::string>(m_key);
226 }
227
228 rbool operator==(const std::string& rhs) const noexceto;
229 operador rbool !=(const std::string& rhs) const noexceto;
230 rbool operator==(const caractere* rhs) const noexceto;
231 operador rbool !=(const caractere* rhs) const noexceto;
232
233 privado:
234 managed() = default;
235 managed ( const managed &) = default ;
236 managed(managed &&) = delete;
237 managed& operator=(const managed&) = delete;
238 managed& operator=(managed&&) = delete;
239 modelo<typename, typename>
240 amigo estrutura, estrutura managed;
241 };
242
243 modelo<>
244 estrutura, estrutura managed<primary_key<Realm::uuid>: managed {
245 primary_key<realm::uuid> detach() const {
246 Método operador, operador Realm::uuid();
247 }
248
249 operador, operador Realm::uuid() const {
250 return m_obj->template get<internal::bridge::uuid>(m_key).operator Realm::uuid();
251 }
252
253 rbool operator==(const Realm::uuid& rhs) const noexceto;
254 operador rbool !=(const Realm::uuid& rhs) const noexceto;
255
256 privado:
257 managed() = default;
258 managed(const managed&) = delete;
259 managed(managed &&) = delete;
260 managed& operator=(const managed&) = delete;
261 managed& operator=(managed&&) = delete;
262 modelo<typename, typename>
263 amigo estrutura, estrutura managed;
264 };
265
266 modelo<>
267 estrutura, estrutura managed<primary_key<Realm::Objeto de Realm> final : managed {
268 primary_key<realm::object_id> detach() const {
269 Método operador, operador Objeto de Realm();
270 }
271
272 operador, operador Objeto de Realm() const {
273 return m_obj->template get<internal::bridge::object_id>(m_key).operator Objeto de Realm();
274 }
275
276 rbool operator==(const Objeto de Realm& rhs) const noexceto;
277 operador rbool !=(const Objeto de Realm& rhs) const noexceto;
278
279 privado:
280 managed() = default;
281 managed(const managed&) = delete;
282 managed(managed &&) = delete;
283 managed& operator=(const managed&) = delete;
284 managed& operator=(managed&&) = delete;
285 modelo<typename, typename>
286 amigo estrutura, estrutura managed;
287 };
288
289 modelo<typename T>
290 estrutura, estrutura managed<primary_key<T>, std::enable_if_t<std::is_enum_v<T>> final : managed_base {
291 primary_key<T> detach() const {
292 Método operador T();
293 }
294
295 operador T() const {
296 Método estático_cast<T>(m_obj->template get<int64_t>(m_key));
297 }
298
299 rbool operator==(const T& rhs) const noexceto {
300 if (This->query) {
301 retornar isto->query>equal(m_key, serializar(rhs));
302 }
303 return serialize(detach().value) == serialize(rhs);
304 }
305 operador rbool !=(const T& rhs) const noexceto {
306 if (This->query) {
307 retornar isto->m_rbool_query->not_equal(m_key, serialize(rhs));
308 }
309 return serialize(detach().value) != serialize(rhs);
310 }
311
312 privado:
313 managed() = default;
314 managed(const managed&) = delete;
315 managed(managed &&) = delete;
316 managed& operator=(const managed&) = delete;
317 managed& operator=(managed&&) = delete;
318 modelo<typename, typename>
319 amigo estrutura, estrutura managed;
320 };
321
322 modelo<>
323 estrutura, estrutura managed<primary_key<std::optional<int64_t>> final : managed_base {
324 primary_key<std::optional<int64_t>> detach() const {
325 Método operador std::opcional<int64_t>();
326 }
327
328 operador std::opcional<int64_t>() const {
329 return m_obj->get_optional<int64_t>(m_key);
330 }
331
332 rbool operator==(const std::opcional<int64_t>& rhs) const noexceto;
333 operador rbool !=(const std::optional<int64_t>& rhs) const noexceto;
334 rbool operator>(const int64_t& RHs) const noexceto;
335 rbool operator>=(const int64_t& RHs) const noexceto;
336 operador rbool <(const int64_t& RHs) const noexceto;
337 operador rbool <=(const int64_t& RHs) const noexceto;
338 rbool operator>(const int& RHs) const noexceto;
339 rbool operator>=(const int& rhs) const noexceto;
340 operador rbool <(const int& rhs) const noexceto;
341 operador rbool <=(const int& rhs) const noexceto;
342
343 privado:
344 managed() = default;
345 managed(managed &&) = delete;
346 managed& operator=(const managed&) = delete;
347 managed& operator=(managed&&) = delete;
348 modelo<typename, typename>
349 amigo estrutura, estrutura managed;
350 };
351
352 modelo<typename T>
353 estrutura, estrutura managed<primary_key<T>, std::enable_if_t<std::conjunction_v<typename initial::type_info::is_optional<T>,
354 std::is_enum<typename T::value_type> >> final : managed {
355 primary_key<T> detach() const {
356 Método operador T();
357 }
358
359 operador T() const {
360 auto v = m_obj->get_optional<int64_t>(m_key);
361 se (v) {
362 Método estático_cast<typename T::value_type>(*v);
363 } mais {
364 return std::nullopt;
365 }
366 }
367
368 rbool operator==(const T& rhs) const noexceto {
369 if (This->query) {
370 retornar isto->query>equal(m_key, serializar(rhs));
371 }
372 return serialize(detach().value) == serialize(rhs);
373 }
374 operador rbool !=(const T& rhs) const noexceto {
375 if (This->query) {
376 retornar isto->m_rbool_query->not_equal(m_key, serialize(rhs));
377 }
378 return serialize(detach().value) != serialize(rhs);
379 }
380
381 privado:
382 managed() = default;
383 managed(const managed&) = delete;
384 managed(managed &&) = delete;
385 managed& operator=(const managed&) = delete;
386 managed& operator=(managed&&) = delete;
387 modelo<typename, typename>
388 amigo estrutura, estrutura managed;
389 };
390
391 modelo<>
392 estrutura, estrutura managed<primary_key<std::optional<std::string>> final : managed_base {
393 primary_key<std::optional<std::string>> detach() const {
394 Método operador std::opcional<std::string>();
395 }
396
397 operador std::opcional<std::string>() const {
398 return m_obj->get_optional<std::string>(m_key);
399 }
400
401 rbool operator==(const std::opcional<std::string>& rhs) const noexceto;
402 operador rbool !=(const std::optional<std::string>& rhs) const noexceto;
403 rbool operator==(const caractere* rhs) const noexceto;
404 operador rbool !=(const caractere* rhs) const noexceto;
405
406 privado:
407 managed() = default;
408 managed(const managed&) = delete;
409 managed(managed &&) = delete;
410 managed& operator=(const managed&) = delete;
411 managed& operator=(managed&&) = delete;
412 modelo<typename, typename>
413 amigo estrutura, estrutura managed;
414 };
415
416 modelo<>
417 estrutura, estrutura managed<primary_key<std::optional<realm::uuid>> final : managed_base {
418 primary_key<std::optional<realm::uuid>> detach() const {
419 Método operador std::opcional<realm::uuid>();
420 }
421
422 operador std::opcional<realm::uuid>() const {
423 auto v = m_obj->obter_opcional<interno::bridge::uuid>(m_key);
424 se (v) {
425 return v->operator ::Realm::uuid();
426 }
427 return std::nullopt;
428 }
429
430 rbool operator==(const std::opcional<realm::uuid>& rhs) const noexceto;
431 operador rbool !=(const std::optional<realm::uuid>& rhs) const noexceto;
432
433 privado:
434 managed() = default;
435 managed(const managed&) = delete;
436 managed(managed &&) = delete;
437 managed& operator=(const managed&) = delete;
438 managed& operator=(managed&&) = delete;
439 modelo<typename, typename>
440 amigo estrutura, estrutura managed;
441 };
442
443 modelo<>
444 estrutura, estrutura managed<primary_key<std::optional<realm::object_id>>> final : managed_base {
445 std::optional<realm::object_id> detach() const {
446 Método operador std::opcional<realm::object_id>();
447 }
448
449 operador std::opcional<realm::object_id>() const {
450 auto v = m_obj->get_optional<Internal::bridge::objeto>(m_key);
451 se (v) {
452 return v->operator ::realm::object_id();
453 }
454 return std::nullopt;
455 }
456
457 rbool operator==(const std::opcional<realm::object_id>& rhs) const noexceto;
458 operador rbool !=(const std::optional<realm::object_id>& rhs) const noexceto;
459
460 privado:
461 managed() = default;
462 managed(const managed&) = delete;
463 managed(managed &&) = delete;
464 managed& operator=(const managed&) = delete;
465 managed& operator=(managed&&) = delete;
466 modelo<typename, typename>
467 amigo estrutura, estrutura managed;
468 };
469}
470
471#endif //CPREALM_MANAGED_PRIMARY_KEY_HPP
Realm::rbool
Definição: rbool.hpp:36
Realm::internal::bridge::objeto
Definição: object_id.hpp:31
Realm::internal::bridge::uuid
Definição: uuid.hpp:32
Realm::managed
Definição: macros.hpp:286
Realm::managed
Definição: obj.hpp:62
Objeto de Realm
Definição: tipos.hpp:56
Realm::primary_key< int64_t >
Definição: managed_primary_key.hpp:43
Realm::primary_key< std::string >
Definição: managed_primary_key.hpp:72
Realm::primary_key
Definição: managed_primary_key.hpp:30
Realm::uuid
Definição: tipos.hpp:35
Generated by doxygen 1.9.4